关于二叉树
    现在有N个元素的数组或者链表，要查找一个元素必须遍历数组直到找到元素。假如元素在是数组中最后一个或者数组中不存在这样的元素，那么很不幸，我们要遍历整个数组。如果N非常大，那将是非常痛苦的一件事情。
用二叉树情况就好多了：
1． 更快的查找
2． 增加元素时，元素被自动排列
原理：
在链表或数组中，元素一个接着一个，如图

 

在二叉树中情况不太一样了

每个元素连着两个元素，左孩子和右孩子。他们存储的值的关系有如下规定
Value（left）<Value（middle）<=Value（right）

排序：
在二叉树中利用递归你能很方便的排序
前序遍历

PrintElement(pTopMostElement)
   .
   .
  void PrintElement(TreeElement* pElement)
  {
    if (pElement)
    {
      PrintElement(pElement->LeftChild)
      pElement->PrintMe()
      PrintElement(pElement->RightChild)
    }
  }

后序遍历：

PrintElementReversed(pTopMostElement)
   .
   .
  void PrintElementReversed(TreeElement* pElement)
  {
    if (pElement)
    {
      PrintElementReversed(pElement->RightChild)
      pElement->PrintMe()
      PrintElementReversed(pElement->LeftChild)
    }
  }

如何使二叉树平衡？
添加元素的顺序将影响二叉树的形态，以3,6,4,8,1,9,2,7,5的顺序得到

以1,2,3,4,5,6,7,8,9将得到

有以下方法可以考虑：
1． 以非排序的元素插入元素，不能要求给出的元素是高度不排序的
2． 以一组随机元素构造二叉树，然后替换这些元素，然后通过旋转得到平衡的树。参考随机树。
3． 重构这稞树

重构整稞树
1． 把元素拷贝到数组中，以升序排序
2． 清空这棵树
3． 从数组中高度不排序的选取元素插入树中可以这样完成第三步：

可以递归的实现：

// Assuming array ranges from [0..arraySize-1]
GetFromOrderedArray(0,arraySize-1)
  .
  .
void GetFromOrderedArray(int lowBound,int highBound)
{
  if (hi < low) return;
  middlePos = lowBound+(highBound-lowBound)/2
  // middlePos is now at the element in the middle
  // between lowBound and highBound, so we just add
  // it to the tree

  AddElement ( theOrderedArray[middlePos] )

  // Pick the middle one "to the left"
  AddFromOrderedArray(lowBound,middlePos-1)

  // Pick the middle one "to the right"
  AddFromOrderedArray(middlePos+1,highBound)
}

删除一个元素

首先要找到要删除的元素E，有两种方法：
1． 通过遍历找到这个元素E
2． 给每个元素一个指向双亲的指针

接下来就是删除的过程了：
1． 剪断E与他双亲的连接
2． 将左右孩子所在的子树同其他元素一样加到树中
3． 删除E

void RemoveElement(TreeElement* theOneToRemove)
{
  TreeElement* pParent = theOneToRemove->GetParent();

  // Ok, so it has a parent, then we'll simply just disconnect it.
  if (pParent)
  {
     if (pParent->GetLeftChild() == theOneToRemove)
     {
        pParent->SetLeftChild(NULL);
     }
     else
     {
        ASSERT(pParent->GetRightChild() == theOneToRemove);
        pParent->SetRightChild(NULL);
     }
  }
  else
  {
     // No parent? Then we're removing the root element.
     theTopMostElement = NULL;
   }

  // Disconnected, now we reconnect its children (if any)
  // just by adding them as we add any other node.
  if (theOneToRemove->GetLeftChild())
   AddElement(theOneToRemove->GetLeftChild());
  if (theOneToRemove->GetRightChild())
   AddElement(theOneToRemove->GetRightChild());

  //Zap the element (if that's what you want to do)
  delete theOneToRemove;

}

注解：

通过函数回调 遍历二叉树

注：函数回调例如AddElement(theOneToRemove->GetRightChild());

简而言之，回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
可以把调用者与被调用者分开。调用者不关心谁是被调用者，所有它需知道的，只是存在一个具有某种特定原型、某些限制条件（如返回值为int）的被调用函数。

                                            #内容选自CodeGuru
若理解错误，欢迎指正！

// mergesort
#include < iostream >
using   namespace  std;

int  merge( int  A[], int  p, int  q, int  r) {
  int  n1 = q - p + 1 ;
  int  n2 = r - q;
  int *  L  =   new   int [n1];
  int *  R  =   new   int [n2];
  for ( int  i = 0 ;i < n1; ++ i)
  L[i] = A[p + i];
for ( int  j = 0 ;j < n2; ++ j)
  R[j] = A[q + 1 + j];
 i = 0 ;j = 0 ;
  int  k = p;
  while (i < n1 && j < n2) {
   if (L[i] <= R[j]) {A[k ++ ] = L[i ++ ];}
   else   {A[k ++ ] = R[j ++ ];}
 }
  while (i < n1) {
  A[k ++ ] = L[i ++ ];}
  while (j < n2) {
  A[k ++ ] = R[j ++ ];}
  return ( 0 );
}

int  mergesort( int  A[], int  p, int  r) {
  int  q;
  if (p < r) {
  q = (p + r) / 2 ;
  mergesort(A,p,q);
  mergesort(A,q + 1 ,r);
  merge(A,p,q,r);
 }
  return ( 0 );
}

int  main() {
     int  b[ 6 ] = { 11 , 65 , 53 , 78 , 38 , 63 } ;
    mergesort(b, 0 , 5 );
  for ( int  i = 0 ;i < 6 ; ++ i)
  cout << b[i] << ' \t ' ;
  return ( 0 );
}

小小的错误，找了我半天

int merge(int*A,int p,int q,int r){
 int n1=q-p+1;
 int n2=r-q;
 int* L = new int[n1];
 int* R = new int[n2];
 for(int i=0;i<n1;++i)
  L[i]=A[p+i];
 for(int j=0;j<n2;++j)
  R[j]=A[q+1+j];
 i=0;j=0;
 for(int k=p;k<r;k++){
  if(L[i]<=R[j]){A[k]=L[i++];}
  else {A[k]=R[j++];}
 }
 return(0);
}

int mergesort(int*A,int p,int r){
 int q;
 if(p<r){
  q=(p+r)/2;
  mergesort(A,p,q);
  mergesort(A,q+1,r);
  merge(A,p,q,r);
 }
 return(0);
}

int main(){
    int b[6]={11,65,53,78,38,63};
    mergesort(b,0,5);
 for(int i=0;i<6;++i)
  cout<<b[i]<<'\t';
 return(0);
}

以下引用自：gooler的专栏http://blog.csdn.net/Gooler/archive/2006/03/22/632422.aspx有各种排序算法quicksort,heapsort...
/*
 * A is an array and p, q, and r are indices numbering elements of the array
 * such that p <= q < r.
 *
 * This procedure assumes that the subarrays A[p. .q] and A[q + 1. .r] are in
 * sorted order. It merges them to form a single sorted subarray that replaces
 * the current subarray A[p. .r].
 */
void merge(int A[], int p, int q, int r) {
    int i, j, k, size;
    int* B;
   
    size = r - p + 1;

    B = new int[size]; /* temp arry for storing the merge result */
   
    /* initialize B */
    for (i = 0; i < size; ++i) {
        B[i] = 0;
    }

    i = p;
    j = q + 1;
    k = 0;
   
    /* compare and copy the smaller to B */
    while (i <= q && j <= r) {
        if (A[i] < A[j]) {
            B[k++] = A[i++];
        } else {
            B[k++] = A[j++];
        }
    }
   
    /* copy the rest to B */
    while (i <= q) {
        B[k++] = A[i++];
    }   
    while (j <= r) {
        B[k++] = A[j++];
    }
   
    /* replace A[p..r] with B[0..r-p] */
    for (i = p, k = 0; i <= r; ++i, ++k) {
        A[i] = B[k];
    }

    delete[] B;
}

/*
 * This procedure sorts the elements in the subarray A[p. .r].
 *
 * If p >= r, the subarray has at most one element and is therefore
 * already sorted. Otherwise, the divide step simply computes an index
 * q that partitions A[p. .r] into two subarrays: A[p. .q], containing n/2
 * elements, and A[q + 1. .r], containing n/2 elements.
 */
void mergeSort(int A[], int p, int r) {
    if (p >= r) return;
   
    int q = (p + r) / 2;
   
    mergeSort(A, p, q);
    mergeSort(A, q + 1, r);
    merge(A, p, q, r);
}