引言：

什麼是四叉樹？

四叉樹是一種資料結構，被用來將一個2D區域分為更多可管理的範圍。它是二叉樹的擴充套件，但是不像二叉樹每個節點有兩個孩子，它有四個孩子。

四叉樹就是把一塊2d的區域，等分成4份,如下圖:    我們把4塊區域從右上象限開始編號， 逆時針。

接著每份繼續等分4份。

四叉樹起始於單節點。物件會被新增到四叉樹的單節點上。

當更多的物件被新增到四叉樹裡時，它們最終會被分為四個子節點。（我是這麼理解的：下面的圖片不是分為四個區域嗎，每個區域就是一個孩子或子節點）然後每個物體根據他在2D空間的位置而被放入這些子節點中的一個裡。任何不能正好在一個節點區域內的物體會被放在父節點。（這點我不是很理解，就這幅圖來說，那根節點的子節點豈不是有五個節點了。）

正如你看到的，每個節點僅包括幾個物體。這樣我們就可以明白前面所說的規則，例如，左上角節點裡的物體是不可能和右下角節點裡的物體碰撞的。所以我們也就沒必要執行消耗很多資源的碰撞檢測演算法來檢驗他們之間是否會發生碰撞。

 使用四叉樹使用四叉樹是非常簡單的。下面的程式碼使用Java寫的，但是同樣的技術可以用很多其他程式語言來寫。我會在每個程式碼片段後面註釋。首先我們開始建立一個重要的四叉樹的類，下面的程式碼就是Quadtree.java。

public class Quadtree {

  private int MAX_OBJECTS = 10;
  private int MAX_LEVELS = 5;

  private int level;
  private List objects;
  private Rectangle bounds;
  private Quadtree[] nodes;

/*
  * Constructor
  */
  public Quadtree(int pLevel, Rectangle pBounds) {
   level = pLevel;
   objects = new ArrayList();
   bounds = pBounds;
   nodes = new Quadtree[4];
  }
}
 

/*
* Clears the quadtree
*/
public void clear() {
   objects.clear();

   for (int i = 0; i < nodes.length; i++) {
     if (nodes[i] != null) {
       nodes[i].clear();
       nodes[i] = null;
     }
   }
}

/*
* Splits the node into 4 subnodes
*/
private void split() {
   int subWidth = (int)(bounds.getWidth() / 2);
   int subHeight = (int)(bounds.getHeight() / 2);
   int x = (int)bounds.getX();
   int y = (int)bounds.getY();

   nodes[0] = new Quadtree(level+1, new Rectangle(x + subWidth, y, subWidth, subHeight));
   nodes[1] = new Quadtree(level+1, new Rectangle(x, y, subWidth, subHeight));
   nodes[2] = new Quadtree(level+1, new Rectangle(x, y + subHeight, subWidth, subHeight));
   nodes[3] = new Quadtree(level+1, new Rectangle(x + subWidth, y + subHeight, subWidth, subHeight));
}

/*
* Determine which node the object belongs to. -1 means
* object cannot completely fit within a child node and is part
* of the parent node
*/
private int getIndex(Rectangle pRect) {
   int index = -1;
   double verticalMidpoint = bounds.getX() + (bounds.getWidth() / 2);
   double horizontalMidpoint = bounds.getY() + (bounds.getHeight() / 2);

   // Object can completely fit within the top quadrants
   boolean topQuadrant = (pRect.getY() < horizontalMidpoint && pRect.getY() + pRect.getHeight() < horizontalMidpoint);
   // Object can completely fit within the bottom quadrants
   boolean bottomQuadrant = (pRect.getY() > horizontalMidpoint);

   // Object can completely fit within the left quadrants
   if (pRect.getX() < verticalMidpoint && pRect.getX() + pRect.getWidth() < verticalMidpoint) {
      if (topQuadrant) {
        index = 1;
      }
      else if (bottomQuadrant) {
        index = 2;
      }
    }
    // Object can completely fit within the right quadrants
    else if (pRect.getX() > verticalMidpoint) {
     if (topQuadrant) {
       index = 0;
     }
     else if (bottomQuadrant) {
       index = 3;
     }
   }

   return index;
}

/*
* Insert the object into the quadtree. If the node
* exceeds the capacity, it will split and add all
* objects to their corresponding nodes.
*/
public void insert(Rectangle pRect) {
   if (nodes[0] != null) {
     int index = getIndex(pRect);

     if (index != -1) {
       nodes[index].insert(pRect);

       return;
     }
   }

   objects.add(pRect);

   if (objects.size() > MAX_OBJECTS && level < MAX_LEVELS) {
     split();

     int i = 0;
     while (i < objects.size()) {
       int index = getIndex(objects.get(i));
       if (index != -1) {
         nodes[index].insert(objects.remove(i));
       }
       else {
         i++;
       }
     }
   }
}

/*
* Return all objects that could collide with the given object
*/
public List retrieve(List returnObjects, Rectangle pRect) {
   int index = getIndex(pRect);
   if (index != -1 && nodes[0] != null) {
     nodes[index].retrieve(returnObjects, pRect);
   }

   returnObjects.addAll(objects);

   return returnObjects;
}

用這個類來進行2D碰撞檢測

現在我們有了完整功能的四叉樹，是時候使用它來幫助我們減少碰撞檢測了。
在一個特定的遊戲裡，開始建立四叉樹，並將螢幕尺寸作為引數傳入（Rectangle的建構函式）。

Quadtree quad = new Quadtree(0, new Rectangle(0,0,600,600));

在每一幀裡，我們都先清除四叉樹再用inset方法將物件插入其中。

quad.clear();
for (int i = 0; i < allObjects.size(); i++) {
  quad.insert(allObjects.get(i));
}

List returnObjects = new ArrayList();
for (int i = 0; i < allObjects.size(); i++) {
  returnObjects.clear();
  quad.retrieve(returnObjects, objects.get(i));

  for (int x = 0; x < returnObjects.size(); x++) {
    // Run collision detection algorithm between objects
  }
}