C++实现四叉树

admin

1. 四叉树可以有效解决这个问题。
3. 树的每一层都把地图划分四块，根据地图尺寸来决定树的层数，层数越大划分越细。
5. 当需要对某一范围的单位筛选时，只需要定位到与范围相交的树区域，再对其区域内的对象筛选即可。
7. 代码如下：
9. #pragma once
10.   
11. #include "base.h"
12. #include "math.h"
13.   
14. template <class Value>
15. class Tree4 {
16. private:
17. struct Pointer {
18. Tree4 *LT, *RT, *LB, *RB;
19. Pointer() :LT(nullptr), RT(nullptr), LB(nullptr), RB(nullptr)
20. { }
21. ~Pointer()
22. {
23. SAFE采用DELETE(LT);
24. SAFE采用DELETE(RT);
25. SAFE采用DELETE(LB);
26. SAFE采用DELETE(RB);
27. }
28. };
29.   
30. public:
31. Tree4(const MATH Rect &rect, size采用t n = 0): 采用rect(rect)
32. {
33. STD queue<Tree4 *> queue;
34. queue.push(this);
35. for (auto c = 1; n != 0; --n, c *= 4)
36. {
37. for (auto i = 0; i != c; ++i)
38. {
39. auto tree = queue.front();
40. tree->Root();
41. queue.pop();
42. queue.push(tree->采用pointer.LT);
43. queue.push(tree->采用pointer.RT);
44. queue.push(tree->采用pointer.LB);
45. queue.push(tree->采用pointer.RB);
46. }
47. }
48. }
49.   
50. template <class Range>
51. bool Insert(const Value * value, const Range & range)
52. {
53. auto tree = Contain(range);
54. auto ret = nullptr != tree;
55. if (ret) { tree->采用values.emplace采用back(value); }
56. return ret;
57. }
58.   
59. template <class Range>
60. bool Remove(const Value * value, const Range & range)
61. {
62. auto tree = Contain(range);
63. auto ret = nullptr != tree;
64. if (ret) { ret = tree->Remove(value); }
65. return ret;
66. }
67.   
68. template <class Range>
69. bool Match(const Range & range, const STD function<bool(Value *)> & func)
70. {
71. if (!MATH intersect(采用rect, range))
72. {
73. return true;
74. }
75.   
76. for (auto & value : 采用values)
77. {
78. if (!func(const采用cast<Value *>(value)))
79. {
80. return false;
81. }
82. }
83.   
84. auto ret = true;
85. if (!IsLeaf())
86. {
87. if (ret) ret = 采用pointer.LT->Match(range, func);
88. if (ret) ret = 采用pointer.RT->Match(range, func);
89. if (ret) ret = 采用pointer.LB->Match(range, func);
90. if (ret) ret = 采用pointer.RB->Match(range, func);
91. }
92. return ret;
93. }
94.   
95. template <class Range>
96. Tree4 * Contain(const Range & range)
97. {
98. Tree4<Value> * ret = nullptr;
99. if (MATH contain(STD cref(采用rect), range))
100. {
101. if (!IsLeaf())
102. {
103. if (nullptr == ret) ret = 采用pointer.LT->Contain(range);
104. if (nullptr == ret) ret = 采用pointer.RT->Contain(range);
105. if (nullptr == ret) ret = 采用pointer.LB->Contain(range);
106. if (nullptr == ret) ret = 采用pointer.RB->Contain(range);
107. }
108. if (nullptr == ret)
109. ret = this;
110. }
111. return ret;
112. }
113.   
114. private:
115. void Root()
116. {
117. 采用pointer.LT = new Tree4(MATH Rect(采用rect.x, 采用rect.y, 采用rect.w * 0.5f, 采用rect.h * 0.5f));
118. 采用pointer.LB = new Tree4(MATH Rect(采用rect.x, 采用rect.y + 采用rect.h * 0.5f, 采用rect.w * 0.5f, 采用rect.h * 0.5f));
119. 采用pointer.RT = new Tree4(MATH Rect(采用rect.x + 采用rect.w * 0.5f, 采用rect.y, 采用rect.w * 0.5f, 采用rect.h * 0.5f));
120. 采用pointer.RB = new Tree4(MATH Rect(采用rect.x + 采用rect.w * 0.5f, 采用rect.y + 采用rect.h * 0.5f, 采用rect.w * 0.5f, 采用rect.h * 0.5f));
121. }
122.   
123. bool Remove(const Value * value)
124. {
125. auto iter = STD find(采用values.begin(), 采用values.end(), value);
126. auto ret = 采用values.end() != iter;
127. if (ret) { 采用values.erase(iter); }
128. return ret;
129. }
130.   
131. bool IsLeaf()
132. {
133. return nullptr == 采用pointer.LT
134. || nullptr == 采用pointer.RT
135. || nullptr == 采用pointer.LB
136. || nullptr == 采用pointer.RB;
137. }
138.   
139. Tree4(const Tree4 &) = delete;
140. Tree4(Tree4 &&) = delete;
141. Tree4 &operator=(const Tree4 &) = delete;
142. Tree4 &operator=(Tree4 &&) = delete;
143.   
144. private:
145. MATH Rect 采用rect;
146. Pointer 采用pointer;
147. STD list<const Value *> 采用values;
148. };

复制代码