非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树

2019年3月16日 358次阅读 来源: 平衡二叉树

转载:http://blog.csdn.net/LG1259156776/article/details/47271673

在上一篇数据结构的博文《数据结构（三）:非线性逻辑结构-二叉树》中已经对二叉树的概念、遍历等基本的概念和操作进行了介绍。本篇博文主要介绍几个特殊的二叉树，堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树，它们在解决实际问题中有着非常重要的应用。本文主要从概念和一些基本操作上进行分类和总结。

一、概念总揽

（1） 堆

堆（heap order）是一种特殊的表，如果将它看做是一颗完全二叉树的层次序列，那么它具有如下的性质：每个节点的值都不大于其孩子的值，或每个节点的值都不小于其孩子的值，前者为小根堆，后者为大根堆。

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

（2） 哈夫曼树

在应用中通常给树中的节点一个有意义的实数，称为该节点的权，该权可能是该节点的度或访问频率等。一个节点和根之间的路径长度与这个节点的权的乘积称为该节点的带权路径长度。树中所有叶子的带权路径长度之和称为树的带权路径长度（weighted path length of tree），通常记为WPL。

在叶子数目为n，其权为w1, w2, w3,….,wn的所有二叉树中树的带权路径长度最小的树称为最优二叉树，通常叫做哈弗曼树。

（3） 二叉搜索树

单向链表的搜索只能从表头开始，逐个扫描，效率低；双向链表通过前驱和后继指针，可以从当前节点向前或向后两个方向进行，但是搜索效率提高不大，因为还是逐个搜索。二叉搜索树（binary search tree）是改进的双向链表，其中每个节点的值不小于左孩子的值，不大于右孩子的值。二叉搜索树能显著改善搜索的性能。

（4） 平衡二叉搜索树

二叉搜索树的查找效率取决于树的形状，一颗形状均匀的二叉搜索树与节点插入的次序有关。如果二叉搜索树极度不均匀，则会退化为双向链表形式的线性逻辑结构，导致搜索效率极度退化。所以，需要一种动态平衡的方法，不依赖节点插入顺序，总是可以保证二叉树的形状均匀。

所谓形状均匀就是指任何节点的左右子树的高度最多相差为1，称之为平衡二叉搜索树。如果将一个节点的左右孩子子树的高度之差称为该节点的平衡因子的话，那么平衡二叉树的任意节点的平衡因子只能是-1,0,1。

（5） 红黑树

红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由Rudolf Bayer发明的，他称之为”对称二叉B树”，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。
红黑树是一种很有意思的平衡检索树。它的统计性能要好于平衡二叉树(有些书籍根据作者姓名，Adelson-Velskii和Landis，将其称为AVL-树)，因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。

（6） 线索二叉树

使用二叉链表无法直接找到每一个节点在某一种遍历序列中的前驱后继，而具有n个节点的二叉链表必定存在n+1个空链域，可以用来存放前驱和后继的指针，并称之为线索（thread），具体的作法：

若节点有左子树，则其左指针指向左孩子；否则另它指向前驱；

若节点有右子树，则其右指针指向右孩子；否则另它指向后继。

为此，二叉链表的节点结构需要增加两个标志域，指明左右链域中的指针是指向左右孩子还是指向前驱后继。

带有线索的二叉链表成为线索链表，相应的二叉树称之为线索二叉树。

二、数据结构之堆

对于学习计算机编程的人，都会听说过堆栈这个概念，但实际上堆栈是两种不同的数据结构：堆和栈。

1. 堆与栈的比较

在数据结构系列博文线性数据结构的《数据结构（二）:线性表包括顺序存储结构（顺序表、顺序队列和顺序栈）和链式存储结构（链表、链队列和链栈）》已经对栈进行过分析，栈的典型特征就是先进后出，后进新出，压入栈和弹出栈等概念。类似于往箱子里存储物品，先放入的物品在最下面，而后放入的物品在上面，在取物品时，必须先取最上面的之后才能取下面的。

那么堆是完全二叉树的的层次序列，是一种经过排序的树形数据结构。常说的堆的数据结构指的就是二叉堆，常用来实现优先队列、堆排序等。比如在图书馆的书架上取书，虽然书的摆放是有序的，但是我们想取任意一本时不必像栈一样，先取出前面所有的书，书架这种机制不同于箱子，我们可以直接取出我们想要的书。

最为直接也最容易混淆的就是内存分配中的堆和栈，这里以C语言程序中的堆栈分配为例进行说明，借鉴了一个大神所写的一段程序，具体如下：

int a = 0; 全局初始化区 
char *p1; 全局未初始化区 
main() 
{ 
int b; //栈 
char s[] = “abc”; //栈 
char *p2; //栈 
char *p3 = “123456”; //123456\0在常量区，p3在栈上。 
static int c =0； //全局（静态）初始化区 
p1 = (char *)malloc(10);  //堆 
p2 = (char *)malloc(20);  //堆 
}

主要的区别就是：栈（stack）是系统自动分配的自动变量，而堆（heap）则是程序员根据需要自己申请的空间，如malloc等，栈空间是自动分配也是自动回收的，而堆则需要程序员自行维护的。另外，在函数调用中，第一个进栈的是主函数中函数调用后的下一条指令的地址，然后是函数的各个参数，在大多数的C编译器，参数是由右向左入栈的，然后是函数中的局部变量，而静态变量是不入栈的。在本次函数调用结束后，局部变量先出栈，然后是参数，最后是栈顶指针指向最开始存的地址，也就是主函数中函数调用后的吓一跳指令，程序由该点继续运行。

2. 堆的存储结构

与顺序表相同：

typedef struct 

{

DataType *data;

int max;

int size;

}Heap;

堆是一种非常有效的数据管理结构，例如每次都是访问最小元素，就可以使用小堆根，因为表中第一个元素总是最小的。

3. 堆的基本操作

堆是一颗完全二叉树，高度为O(lg n)，其基本操作至多与树的高度成正比。

Void FilterUp(Heap *H);
Void FilterDown(Heap *H);
Void SetHeap(Heap *H,int n);
Void FreeHeap(Heap *H);
Void HeapInsert(Heap *H,DataType item);
DataType HeapDelete(Heap *H);

堆运算的特点是删除和插入（以小堆根为例）

（1） 删除

删除第一个元素,用最后一个元素填补
调整顺序,将根结点和其左右孩子较小的比,大交换,直到恢复秩序.

（2）插入

新元素插尾,
从尾开始和双亲比较,小于双亲交换.
比较或者移动的次数不超过完全二叉树的深度
利用堆排序相当于折半查，效率高.

4. 堆的应用

（1） 堆排序

堆排序(HeapSort)是一树形选择排序。
堆排序的特点是：在排序过程中，将R[1..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系，在当前无序区中选择关键字最大(或最小)的记录。
优 点
直接选择排序中，为了从R[1..n]中选出关键字最小的记录，必须进行n-1次比较，然后在R[2..n]中选出关键字最小的记录，又需要做n-2次比较。事实上，后面的n-2次比较中，有许多比较可能在前面的n-1次比较中已经做过，但由于前一趟排序时未保留这些比较结果，所以后一趟排序时又重复执行了这些比较操作。
堆排序可通过树形结构保存部分比较结果，可减少比较次数。

参考代码如下：


[cpp] 
view plain
 copy

  1. ////////////////////////////////////////////////////////////////////   
  2. //堆排序  
  3. template <class t=“”>  
  4. void Sort::HeapSort(T arr[], int len){  
  5.     int i;   
  6.       
  7.     //建立子堆   
  8.     for(i = len / 2; i >= 1; i–){  
  9.         CreateHeap(arr, i, len);  
  10.     }  
  11.       
  12.     for(i = len – 1; i >= 1; i–){  
  13.         buff = arr[1];  
  14.         arr[1] = arr[i + 1];  
  15.         arr[i + 1] = buff;   
  16.           
  17.         CreateHeap(arr, 1, i);   
  18.     }  
  19. }   
  20.   
  21.   
  22. //建立堆   
  23. template <class t=“”>  
  24. void Sort::CreateHeap(T arr[], int root, int len){  
  25.     int j = 2 * root;                   //root’s left child, right (2 * root + 1)   
  26.     T temp = arr[root];  
  27.     bool flags = false;   
  28.       
  29.     while(j <= len && !flags){  
  30.         if(j < len){  
  31.             if(arr[j] < arr[j + 1]){     // Left child is less then right child   
  32.                 ++j;                // Move the index to the right child   
  33.             }     
  34.         }  
  35.           
  36.         if(temp < arr[j]){  
  37.             arr[j / 2] = arr[j];  
  38.             j *= 2;   
  39.         }else{  
  40.             flags = true;   
  41.         }   
  42.     }   
  43.    arr[j / 2]  = temp;   
  44. } </class></class>  



（2） 优先队列

优先队列是一种用来维护由一组元素构成的集合S的数据结构。在C++标准模板库中有priority_queue的实现，但是对于其数据结构还是需要进行分析：

优先队列和通常的栈和队列一样，只是每个元素有一个优先级，在处理时总是处理优先级最高的，如果两个元素具有相同的优先级，则按照它们插入到队列中的先后顺序处理。优先队列可以通过链表、数组、堆或者其它数据结构实现。

具体实现可以参考一下代码：


[cpp] 
view plain
 copy

  1. #include <iostream>  
  2. #include <vector>  
  3. using namespace std;  
  4.   
  5. class Heap  
  6. {  
  7. public:  
  8.     Heap(int iSize);  
  9.     ~Heap();  
  10.   
  11.     int Enqueue(int iVal);  
  12.     int Dequeue(int &iVal);  
  13.     int GetMin(int &iVal);  
  14.     void printQueue();  
  15. protected:  
  16.     int *m_pData;  
  17.     int m_iSize;  
  18.     int m_iAmount;  
  19. };  
  20. Heap::Heap(int iSize = 100)//注意这里是从0开始，所以如果根是i，那么左孩子是2*i+1，右孩子是2*i+2  
  21. {  
  22.     m_pData = new int[iSize];  
  23.     m_iSize = iSize;  
  24.     m_iAmount = 0;  
  25. }  
  26. Heap::~Heap()  
  27. {  
  28.     delete []m_pData;  
  29. }  
  30.   
  31. int Heap::Enqueue(int iVal)//进入堆  
  32. {  
  33.     if (m_iAmount == m_iSize)  
  34.     {  
  35.         return 0;  
  36.     }  
  37.     m_pData[m_iAmount ++] = iVal;  
  38.     int iIndex = m_iAmount – 1;  
  39.     while (m_pData[iIndex] < m_pData[(iIndex – 1) /2])//上浮，直到满足最小堆  
  40.     {  
  41.         swap(m_pData[iIndex],m_pData[(iIndex – 1) /2]);  
  42.         iIndex = (iIndex – 1) /2;  
  43.     }  
  44.     return 1;  
  45. }  
  46.   
  47. int Heap::Dequeue(int &iVal)//出堆  
  48. {  
  49.     if (m_iAmount == 0)  
  50.     {  
  51.         return 0;  
  52.     }  
  53.     iVal = m_pData[0];//出堆的数据  
  54.     m_pData[0] = m_pData[m_iAmount – 1];//最后一个数据放到第一个根上面  
  55.     — m_iAmount;//总数减1  
  56.     int rc = m_pData[0];  
  57.     int s = 0;  
  58.     for (int j = 2*s +1; j < m_iAmount; j *= 2)//最后一个数放到第一个位置以后，开始下沉，来维持堆的性质  
  59.     {  
  60.         if (j < m_iAmount – 1 && m_pData[j] > m_pData[j+1])  
  61.         {  
  62.             ++ j;  
  63.         }  
  64.         if (rc < m_pData[j])//rc应该插入在s位置上  
  65.         {  
  66.             break;  
  67.         }  
  68.         m_pData[s] = m_pData[j];  
  69.         s = j;  
  70.     }  
  71.     m_pData[s] = rc;  
  72.     return 1;  
  73. }  
  74.   
  75. int Heap::GetMin(int &iVal)  
  76. {  
  77.     if (m_iAmount == 0)  
  78.     {  
  79.         return 0;  
  80.     }  
  81.     iVal = m_pData[0];  
  82.     return 1;  
  83. }  
  84.   
  85. void Heap::printQueue()  
  86. {  
  87.     for (int i = 0; i < m_iAmount; ++ i)  
  88.     {  
  89.         cout << m_pData[i] << ” “;  
  90.     }  
  91.     cout << endl;  
  92. }  
  93. int main()  
  94. {  
  95.     Heap heap;  
  96.     heap.Enqueue(4);  
  97.     heap.Enqueue(1);  
  98.     heap.Enqueue(3);  
  99.     heap.Enqueue(2);  
  100.     heap.Enqueue(6);  
  101.     heap.Enqueue(5);  
  102.     heap.printQueue();  
  103.   
  104.     int iVal;  
  105.     heap.Dequeue(iVal);  
  106.     heap.Dequeue(iVal);  
  107.   
  108.     heap.printQueue();  
  109.     return 0;  
  110. }</vector></iostream>  



5. 总结

对于堆这样的数据结构，只要清楚两个基本的操作：删除和插入即可。为了维持大根堆与小根堆的结构，必须进行调整。采用队列的形式，从堆顶删除，从堆尾插入，这样就可以实现优先队列结构。另外，特别注意，堆在存储结构上虽然采用了线性表的形式，但是在逻辑结构上属于完全二叉树，因此其在线性表中的索引也就有了如下的关系式：

对于在线性表中的索引index，下表索引从0开始，如果有双亲和孩子结点，那么双亲结点在线性表中的索引为( index – 1) / 2，而孩子结点在线性表中的索引为左孩子为（index*2+1） ，而右孩子为（index*2+2）。知道了这些，对于调整heap结构就十分方便了。

三、数据结构之哈夫曼树

1. huffman 树

带权、路径长度最短的树
路径：从树中一个结点到另一个结点之间的分支构成这两个结点间的~
路径长度：路径上的分支数
树的路径长度：从树根到每一个结点的路径长度之和
在许多应用中，常常将树中结点赋予一个有某种意义的实数，称为该结点的权。
结点的带权路径长度：是该结点到树根之间的路径长度与结点上权的乘积。
树的带权路径长度：树中所有叶子结点(k)的带权路径长度ωk lk之和， 记做WPL.

下面通过一个实例进行说明：有4个结点，权值分别为7，5，2，4，构造有4个叶子结点的二叉树

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

设有n个权值{w1,w2,……wn}，
构造一棵有n个叶子结点的二叉树，每个叶子权值为wi,则WPL最小的二叉树叫Huffman树
哈夫曼树中没有度为1的结点，称为严格的二叉树

2. huffman算法

构造Huffman树的方法：Huffman算法

1.根据给定的n个权值{w1,w2,……wn}，构造n棵只有根结点的二叉树Tj，令其权值为wj
2.在森林中选取两棵根结点权值最小的树作左右子树，构造一棵新的二叉树，置新二叉树根结点权值为其左右子树根结点权值之和
3.在森林中删除这两棵树，同时将新得到的二叉树加入森林中
4.重复上述两步，直到只含一棵树为止，这棵树即哈夫曼树

w={7,5,2,4}

构建步骤如下图所示：

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

3. 采用堆来构造Huffman树

顺序表中是n个权，
1。每个权生成一个仅有根的二叉链表，将根指针入堆。
2。从堆中删除2个结点，权和生成双亲结点，根入堆。
重复直2步骤n-1次。返回根指针。

解释说明：将每个权生成的仅有root的二叉链表的根指针全部入堆，这样堆顶就是最小的权，然后从堆中删除两个节点，根据堆的性质，删除的两个节点刚好就是最小的两个权值，从这两个权值构造一个双亲节点，并将root入堆，然后重复该步骤，每次都选取两个最小的权去构造新的子树，并将入堆，这样重复n-1次之后就构成了Huffman树。算法中采用了堆这个具有排序结构（优先级）的数据结构，能够很好的解决生成Huffman树的问题。

4. huffman树节点的存储结构及代码实现

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》


[cpp] 
view plain
 copy

  1. #define n                   /*叶子数目*/  
  2. #define m 2*n-1             /*结点总数*/  
  3. typedef char datatype;  
  4. typedef struct  
  5. {float weight;  
  6. datatype data;  
  7. int lchild,rchild,parent;  
  8. }hufmtree;  
  9. hufmtree tree[m];           /* huffman树的静态三叉链表表示*/  
  10.   
  11.   
  12.   
  13. HUFFMAN(hufmtree tree[])  
  14. {  
  15.     int i,j,p;  
  16.     char ch;  
  17.     float small1,small2,f;  
  18.     for(i=0;i<m;i++) *初始化*=“” {=“” tree[i].parent=“0;” tree[i].lchild=“0;” tree[i].rchild=“0;” tree[i].weight=“0.0;” tree[i].data=“‘0’;” }=“” for(i=“0;i<n;i++)” *输入前n个结点的权值*=“” scanf(“%f”,&f);=“” scanf(“%c”,&ch);=“” *=“” 进行n-1次合并，产生n-1个新结点*=“” p1=“p2=0;” small1=“small2=Maxval;” maxval是float类型的最大值*=“” for(j=“0;j<=i-1;j++)” if(tree[j].parent=“=0)” if(tree[j].weight<small1)=“” *改变最小权次小权及对应位置*=“” small2=“small1;” p2=“p1;” else=“” if(tree[j].weight<small2)=“” *改变次小权及位置*=“” tree[p1].parent=“i;” 合并的两个结点的双亲域赋值=“” tree[p2].parent=“i;” +=“” tree[p2].weight;=“” }<=“” pre=“”></m;i++)>  



5. Huffman树的应用：Huffman编码

数据通信用的二进制编码

思想：根据字符出现频率编码，使电文总长最短编码：

根据字符出现频率构造Huffman树，然后将树中结点引向其左孩子的分支标 “0”，引向其右孩子的分支标“1”；每个字符的编码即为从根到每个叶子的路径上得到的0、1序列

举例说明：它们的出现频率依次为4、7、5、2、9，试画出对应的哈夫曼树(请按左子树根结点的权小于等于右子树根结点的权的次序构造)，并求出每个字符的哈夫曼编码

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

具体的编码数组结构描述如下:

typedef char datatype;
typedef struct
{
    char bits[n];
    int start;
    datatype data;
}codetype;
codetype code[n];

编码算法的基本思想：

从叶子tree[i]出发，利用双亲地址找到双亲结点tree[p]，再利用tree[p]的lchild和rchild指针域判断tree[i] 是tree[p]的左孩子还是右孩子，然后决定分配代码是“0”还是“1”，然后以tree[p]为出发点继续向上回溯，直到根结点为止。

Huffman编码实现如下：


[cpp] 
view plain
 copy

  1. #define n                                               /*叶子数目*/  
  2. #define m 2*n-1                                         /*结点总数*/  
  3. typedef char datatype;  
  4. typedef struct  
  5. {float weight;  
  6. datatype data;  
  7. int lchild,rchild,parent;  
  8. }hufmtree;  
  9. hufmtree tree[m];                                       /* huffman树的静态三叉链表表示*/  
  10.   
  11. typedef char datatype;  
  12. typedef struct  
  13. {  
  14.     char bits[n];  
  15.     int start;  
  16.     datatype data;  
  17. }codetype;  
  18. codetype code[n];  
  19.   
  20. HUFFMANCODE(codetype code[], hufmtree tree[])           /*code存放求出的哈夫曼编码的数组，tree为已知的哈夫曼树*/  
  21. {   
  22.     int i, c, p;  
  23.     codetype cd;                                        /*cd为缓冲变量*/  
  24.     for(i=0; i<n; i++)=“” *n为叶子结点数目*=“” {=“” cd.start=“n;” c=“i;” *从叶子结点出发向上回溯*=“” p=“tree[c].parent;cd.data=tree[c].data;” while(p!=“0)” cd.start–;=“” if(tree[p].lchild=“=c)” cd.bits[cd.start]=“‘0’;” else=“” }=“” code[i]=“cd;” *char编码实例*=“” void=“” charsethuffmanencoding(huffmant=“” t,=“” huffmancode=“” h)=“” *根据huffman树t=“” 求huffman编码表h*=“” int=“” c,=“” p,=“” i;=“” *=“” 和p=“” 分别指示t=“” 中孩子和双亲的位置*=“” char=“” cd[n+1];=“” 临时存放编码*=“” start;=“” 指示编码在cd=“” 中的位置*=“” cd[n]=“‘\0’;” 编码结束符*=“” for(=“” i=“0;” <n;=“” i++){=“” 依次求叶子t[i]的编码*=“” h[i].ch=“getchar();” 读入叶子t[i]对应的字符*=“” start=“n;” 编码起始位置的初值*=“” 从叶子t[i]开始上溯*=“” while((p=“T[c].parent)”>=0){                      /* 直到上溯到T[c]是树根位置*/  
  25.             cd[–start]=(T[p].lchild==c)? ’0’ : ’1’;    /* 若T[c]是T[p]的左孩子，则生成代码0，否则生成代码1*/  
  26.             c=p;                                        /* 继续上溯*/  
  27.         }  
  28.         strcpy(H[i].bits,&cd[start]);                   /*复制编码为串于编码表H*/  
  29.     }  
  30. }</n;>  

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

6. 总结

Huffman树是一个最优二叉树，体现的是叶子节点的带权路径长度和最小。在应用中可以进行Huffman编码，先根据字符出现的频率大小，尽量让出现频率少的字符具有较长的编码，而出现频率大的字符具有较短的编码，这样就能使得编码的压缩效果最好。哈弗曼进行编码的过程包括两个，先根据字符出现频率大小来构建Huffman树，然后从叶子节点出发，到根节点或者从根节点出发到叶子节点，就可以得到该字符的二进制编码。这样的操作能够保证报文的编码长度最小。另外，哈弗曼树可以进行译码，与编码的过程相反，从哈弗曼树的根节点开始，如果遇见0则走左孩子子树，如果遇见1则走右孩子子树，然后一直到叶子节点。这样就得到了该二进制串的字符含义。

四、数据结构之二叉搜索树

1. 基本结构

二叉排序树或是一棵空树，或是具有下列性质的二叉树：

若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值
若它的右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值
它的左、右子树也分别为二叉排序树

二叉搜索树的中序遍历序列是一个有序的序列，它能够显著的提升搜索性能，找到一个数据的路径最长不超过树的深度，搜索性能最优的是完全二叉树。二叉搜索树的存储结构如下：


[cpp] 
view plain
 copy

  1. typedef int DataType;   
  2. typedef struct node  
  3. {  
  4.     DataType data;  
  5.     struct node *left,*right;  
  6. }TNode;  
  7.   
  8. typedef struct  
  9. {  
  10.     TNode *root;  
  11.     int size;  
  12. }BSTree;  


2. 基本操作

（1） 插入

插入原则：若二叉排序树为空，则插入结点应为新的根结点；否则，继续在其左、右子树上查找，直至某个叶子结点的左子树或右子树为空为止，则插入结点应为该叶子结点的左孩子或右孩子。实现代码如下：


[cpp] 
view plain
 copy

  1. bstnode *INSERTBST(t,s)                         /*t为二叉排序树的根指针,s为输入的结点指针*/  
  2. {  
  3.     bstnode *f, *p;  
  4.     p=t;  
  5.     while(p!=NULL)  
  6.     {  
  7.         f=p;                                    /* 查找过程中，f指向*p的双亲*/  
  8.         if(s->key==p->key) return t;            /* 树中已有结点*s，无须插入*/  
  9.         if(s->key<p->key) p=p->lchild;          /* 在左子树中查找插入位置*/  
  10.         else p=p->rchild;                       /* 在右子树中查找插入位置*/  
  11.     }  
  12.     if(t==NULL) return s;                       /*原树为空，返回s作为根指针*/  
  13.     if(s->key<f->key) f->lchild=s;              /* 将*s插入为*f的左孩子*/  
  14.     else f->rchild=s;                           /* 将*s插入为*f的右孩子*/  
  15.     return t;  
  16. }  
  17. </f-></p->  


（2） 生成

二叉排序树生成：从空树出发，经过一系列的查找、插入操作之后，可生成一棵二叉排序树

举例说明：

{10， 18， 3， 8， 12， 2， 7， 3}

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

（3） 删除

要删除二叉排序树中的p结点，分三种情况

 p为叶子结点:

只需修改p双亲f的指针f->lchild=NULL f->rchild=NULL

p只有左子树或右子树

p只有左子树，用p的左孩子代替p        (1)(2)

p只有右子树，用p的右孩子代替p        (3)(4)

p左、右子树均非空

沿p左子树的根C的右子树分支找到S，S的右子树为空，将S的左子树成为S的双亲Q的右子树，用S取代p    (5)

令p的左子树为f(f为p的双亲)的左子树，而p的右子树为S的右子树 (6)


五、数据结构之平衡二叉搜索树

1. 基本概念

二叉搜索树的查找效率取决于树的形状，一颗形状均匀的二叉搜索树与节点插入的次序有关。如果二叉搜索树极度不均匀，则会退化为双向链表形式的线性逻辑结构，导致搜索效率极度退化。所以，需要一种动态平衡的方法，不依赖节点插入顺序，总是可以保证二叉树的形状均匀。

所谓形状均匀就是指任何节点的左右子树的高度最多相差为1，称之为平衡二叉搜索树。如果将一个节点的左右孩子子树的高度之差称为该节点的平衡因子的话，那么平衡二叉树的任意节点的平衡因子只能是-1,0,1。

Adelson-Velskii和Landis提出了一种动态平衡方法，可以实现平衡二叉搜索树，简称为AVL树。

2. 具体实现

在AVL树的实现中比较困难的在于删除和添加后的二叉树结构的动态调整，这里主要通过四个动态调整的方法，具体可以参考代码中的注释

存储结构的实现及基本操作函数声明：


[cpp] 
view plain
 copy

  1. /* 
  2.  在原来二叉链表结构中（BSTree.h的TNode结构中）增加一个整型数据，代表平衡因子，初始为0 
  3. */  
  4. typedef int DataType;   
  5. typedef struct node  
  6. {  
  7.     DataType data;  
  8.     int balance;  
  9.     struct node *left,*right;  
  10. }TNode;  
  11.   
  12. typedef struct  
  13. {  
  14.     TNode *root;  
  15.     int size;  
  16. }BSTree;  
  17.   
  18. /* 
  19.  基本操作函数声明 
  20. */  
  21. void SetTNode(TNode *root,DataType item);  
  22. TNode * GetTNode(DataType item,TNode *left,TNode * right);  
  23. void Preorder(TNode * root); //先序遍历  
  24. void Midorder(TNode * root); //中序遍历  
  25. void Baorder(TNode * root);  //后序遍历  
  26.   
  27. /* 
  28.  动态平衡的调整方法 
  29. */  
  30. void LL(TNode **a,TNode **b);  
  31. void LR(TNode **a,TNode **b);  
  32. void RR(TNode **a,TNode **b);  
  33. void RL(TNode **a,TNode **b);  
  34.   
  35. /* 
  36.  建立和释放平衡二叉搜索树 
  37. */  
  38. void SetBST(BSTree *T);  
  39. void FreeBST(BSTree *T);  
  40.   
  41. void DeleteTree(TNode * root); //删除  
  42. TNode * BSTLocate(BSTree *T,DataType item); // 查找  
  43. void BSTInsert(BSTree *T,DataType item); // 插入数据  
  44. int BSTreeDepth(TNode * tnode); //求树的深度  



基本操作函数的实现如下：


[cpp] 
view plain
 copy

  1. void SetTNode(TNode *root,DataType item)  
  2. {  
  3.     root->data=item;  
  4.     root->balance=0;  
  5.     root->left=root->right=NULL;  
  6. }  
  7. TNode * GetTNode(DataType item,TNode *left,TNode * right)  
  8. {  
  9.     TNode *ptr;  
  10.     ptr=(TNode *)malloc(sizeof(TNode));  
  11.     ptr->data=item;  
  12.     ptr->balance=0;  
  13.     ptr->left=left;  
  14.     ptr->right=right;  
  15.     return(ptr);  
  16.   
  17. }  
  18.   
  19. void SetBST(BSTree *T)  
  20. {  
  21.     T->root=NULL;  
  22.     T->size=0;  
  23. }  
  24. void DeleteTree(TNode * root)  
  25. {  
  26.     if(root==NULL) return;  
  27.     if(root->left!=NULL)  
  28.         DeleteTree(root->left);  
  29.     if(root->right!=NULL)  
  30.         DeleteTree(root->right);  
  31.     free(root);  
  32.   
  33. }   
  34.   
  35. void FreeBST(BSTree *T)  
  36. {  
  37.     DeleteTree(T->root);  
  38. }  
  39.   
  40. TNode * BSTLocate(BSTree *T,DataType item)  
  41. {  
  42.     TNode *t;  
  43.     t=T->root;  
  44.     while(t!=NULL)  
  45.     {  
  46.         if(item==t->data)  
  47.             break;  
  48.         if(item<t->data)  
  49.             t=t->left;  
  50.         else  
  51.             t=t->right;  
  52.     }  
  53.     return(t);  
  54. }  
  55.   
  56. void LL(TNode **a,TNode **b)  
  57. {  
  58.     (*a)->left=(*b)->right;  
  59.     (*a)->balance=0;  
  60.     (*b)->right=(*a);  
  61.     (*b)->balance=0;  
  62. }  
  63. void RR(TNode **a,TNode **b)  
  64. {  
  65.   
  66.     (*a)->right=(*b)->left;  
  67.     (*a)->balance=0;  
  68.     (*b)->left=(*a);  
  69.     (*b)->balance=0;  
  70. }  
  71. void LR(TNode **a,TNode **b)  
  72. {  
  73.     TNode *c;  
  74.     c=(*b)->right;  
  75.     (*a)->left=c->right;  
  76.     (*b)->right=c->left;  
  77.     c->left=(*b);  
  78.     c->right=(*a);  
  79.     switch(c->balance)  
  80.     {  
  81.     case 0:(*a)->balance=0;  
  82.            (*b)->balance=0;  
  83.            break;  
  84.     case 1:(*a)->balance=-1;  
  85.            (*b)->balance=0;  
  86.            break;  
  87.     case -1:(*a)->balance=0;  
  88.            (*b)->balance=1;  
  89.            break;  
  90.     }  
  91.     c->balance=0;  
  92.     (*b)=c;  
  93.   
  94. }  
  95. void RL(TNode **a,TNode **b)  
  96. {  
  97.   
  98.     TNode *c;  
  99.     c=(*b)->left;  
  100.     (*a)->right=c->left;  
  101.     (*b)->left=c->right;  
  102.     c->left=(*a);  
  103.     c->right=(*b);  
  104.     switch(c->balance)  
  105.     {  
  106.     case 0:(*a)->balance=0;  
  107.            (*b)->balance=0;  
  108.            break;  
  109.     case 1:(*a)->balance=0;  
  110.            (*b)->balance=-1;  
  111.            break;  
  112.     case -1:(*a)->balance=1;  
  113.            (*b)->balance=0;  
  114.            break;  
  115.     }  
  116.     c->balance=0;  
  117.     (*b)=c;  
  118. }  
  119.   
  120. void BSTInsert(BSTree *T,DataType item)  
  121. {  
  122.     TNode *t,*p,*new1,*a,*b,*f;  
  123.     new1=GetTNode(item,NULL,NULL);  
  124.     if(T->size==0)  
  125.     {  
  126.         T->root=new1;  
  127.         T->size++;  
  128.         return;  
  129.     }  
  130.     t=T->root;p=NULL;  
  131.     a=t;f=p;  
  132.     while(t!=NULL)  
  133.     {  
  134.         if(t->balance!=0)  
  135.         {  
  136.             a=t;f=p;  
  137.         }  
  138.         p=t;  
  139.         if(item<p->data)  
  140.             t=t->left;  
  141.         else  
  142.             t=t->right;  
  143.   
  144.     }  
  145.     if(item<p->data)  
  146.         p->left=new1;  
  147.     else  
  148.         p->right=new1;  
  149.     T->size++;  
  150.     if(item<a->data)  
  151.         b=t=a->left;  
  152.     else  
  153.         b=t=a->right;  
  154.     while(t!=NULL&&t->data!=item)  
  155.        if(item<t->data)  
  156.        {t->balance=1;t=t->left;  
  157.        }  
  158.        else  
  159.        {t->balance=-1;t=t->right;  
  160.        }  
  161.     if(a->balance==0)  
  162.         if(item<a->data)  
  163.         {a->balance=1;return;}  
  164.         else  
  165.         {a->balance=-1;return;}  
  166.     else  
  167.         if(item<a->data&&a->balance==-1||item>a->data&&a->balance==1)  
  168.         {a->balance=0;return;}  
  169.         else  
  170.         {  
  171.             if(a->balance==1)  
  172.                 if(b->balance==1) LL(&a,&b);  
  173.                 else LR(&a,&b);  
  174.             else  
  175.                 if(b->balance==-1) RR(&a,&b);  
  176.                 else RL(&a,&b);  
  177.         }  
  178.     if(f==NULL) T->root=b;  
  179.     else   
  180.     {   if(f->left==a)  
  181.             f->left=b;  
  182.         else  
  183.             f->right=b;  
  184.     }  
  185. }  
  186.   
  187. int BSTreeDepth(TNode *tnode)  
  188. {  
  189.     int i,j;  
  190.     if (!tnode)   
  191.     {  
  192.         return 0;  
  193.     }  
  194.     i=BSTreeDepth(tnode->left);  
  195.     j=BSTreeDepth(tnode->right);  
  196.     return i>j?i+1:j+1;  
  197. }  
  198.   
  199. void Preorder(TNode * root)  
  200. {  
  201.     CString str0;  
  202.     if(root==NULL)  
  203.         return;  
  204.     str0.Format(“->%d”,root->data);  
  205.     str1+=str0;  
  206.     if(root->left!=NULL) Preorder(root->left);  
  207.     if(root->right!=NULL) Preorder(root->right);  
  208. }  
  209.   
  210. void Midorder(TNode * root)  
  211. {  
  212.     CString str0;  
  213.     if(root==NULL)  
  214.         return;  
  215.     if(root->left!=NULL) Midorder(root->left);  
  216.       
  217.     str0.Format(“->%d”,root->data);  
  218.     str2+=str0;  
  219.     if(root->right!=NULL) Midorder(root->right);  
  220. }  
  221.   
  222. void Baorder(TNode * root)  
  223. {  
  224.     CString str0;  
  225.     if(root==NULL)  
  226.         return;  
  227.       
  228.     Baorder(root->left);  
  229.     Baorder(root->right);  
  230.   
  231.     str0.Format(“->%d”,root->data);  
  232.     str3+=str0;  
  233. }  
  234.   
  235. </a-></a-></t-></a-></p-></p-></t->  



3. AVLTree的一个demo

实现了一个可用于展示动态平衡二叉树的演示程序，具体的效果见下图：

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

具体的工程见：动态平衡二叉树demo

六、数据结构之红黑树

1. 基本概念

红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由Rudolf Bayer发明的，他称之为”对称二叉B树”，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。
红黑树是一种很有意思的平衡检索树。它的统计性能要好于平衡二叉树(有些书籍根据作者姓名，Adelson-Velskii和Landis，将其称为AVL-树)，因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。

2. 红黑树的性质

首先红黑树是二叉查找树，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的，所以是一种近似平衡二叉搜索树。

那么必须满足如下二叉查找树的性质：

（1）.在一棵二叉查找树上，执行查找、插入、删除等操作，的时间复杂度为O（lgn）。
    因为，一棵由n个结点，随机构造的二叉查找树的高度为lgn，所以顺理成章，一般操作的执行时间为O（lgn）。
    //至于n个结点的二叉树高度为lgn的证明，可参考算法导论 第12章 二叉查找树 第12.4节。
（2）.但若是一棵具有n个结点的线性链，则此些操作最坏情况运行时间为O（n）。

而红黑树能保证在最坏的情况下，基本动态几何操作时间均为O（lgn）

红黑树上每个结点内含五个域，color，key，left，right，p。如果相应的指针域没有，则设为NIL。
一般的，红黑树，满足以下性质，即只有满足以下全部性质的树，我们才称之为红黑树：
1）每个结点要么是红的，要么是黑的。
2）根结点是黑的。
3）每个叶结点，即空结点（NIL）是黑的。
4）如果一个结点是红的，那么它的俩个儿子都是黑的。
5）对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点。

如图所示：

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

3. 树的旋转

在对红黑树进行插入和删除等操作时，对树做了修改，那么可能会违背红黑树的性质。
 
为了保持红黑树的性质，我们可以通过对树进行旋转，即修改树种某些结点的颜色及指针结构，以达到对红黑树进行
插入、删除结点等操作时，红黑树依然能保持它特有的性质（如上文所述的，五点性质）。
 
树的旋转，分为左旋和右旋，以下借助图来做形象的解释和介绍：

（1） 左旋

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

（2） 右旋

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

4. 红黑树的具体实现

参看如下代码，具体实现红黑树的左旋和右旋，以及删除、插入等操作：


[cpp] 
view plain
 copy

  1. /*  
  2. 性质1. 节点是红色或黑色  
  3. 性质2. 根是黑色  
  4. 性质3. 每个红色节点的两个子节点都是黑色 (从每个叶子到根的所有路径上不能有两个连续的红色节点)  
  5. 性质4. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点  
  6. */   
  7.   
  8. #include <stdio.h>   
  9. #include <stdlib.h>   
  10. typedef enum Color //定义红黑树结点颜色颜色类型   
  11. {   
  12.     RED = 0,   
  13.     BLACK = 1   
  14. }Color;   
  15.   
  16. typedef struct Node //定义红黑树结点类型   
  17. {   
  18.     struct Node *parent;   
  19.     struct Node *left;   
  20.     struct Node *right;   
  21.     int value;   
  22.     Color color;   
  23. }Node, *Tree;   
  24. Node *nil=NULL; //为了避免讨论结点的边界情况，定义一个nil结点代替所有的NULL   
  25.   
  26. Node* Parent(Node *z) //返回某结点的父母   
  27. {   
  28.     return z->parent;   
  29. }   
  30. Node* Left(Node *z) //返回左子树   
  31. {   
  32.     return z->left;   
  33. }   
  34. Node *Right(Node *z) //返回右子树   
  35. {   
  36.     return z->right;   
  37. }   
  38. void LeftRotate(Tree &T, Node *x) //左旋转：结点x原来的右子树y旋转成为x的父母   
  39. {   
  40.     if( x-> right != nil )   
  41.     {   
  42.         Node *y=Right(x);   
  43.         x->right=y->left;   
  44.         if(y->left != nil)   
  45.         {   
  46.             y->left->parent=x;   
  47.         }   
  48.         y->parent=x->parent;   
  49.         if( x->parent == nil )   
  50.         {   
  51.             T=y;   
  52.         }   
  53.         else   
  54.         {   
  55.             if( x == Left(Parent(x)) )   
  56.             {   
  57.                 x->parent->left=y;   
  58.             }   
  59.             else   
  60.             {   
  61.                 x->parent->right=y;   
  62.             }   
  63.         }   
  64.         y->left=x;   
  65.         x->parent=y;   
  66.     }   
  67.     else   
  68.     {   
  69.         printf(“%s/n”,“can’t execute left rotate due to null right child”);   
  70.     }   
  71. }   
  72.   
  73. void RightRotate(Tree &T, Node *x) //右旋转：结点x原来的左子树y旋转成为x的父母   
  74. {   
  75.     if( x->left != nil )   
  76.     {   
  77.         Node *y=Left(x);   
  78.         x->left=y->right;   
  79.         if( y->right != nil )   
  80.         {   
  81.             y->right->parent=x;   
  82.         }   
  83.         y->parent=x->parent;   
  84.         if( x->parent == nil )   
  85.         {   
  86.             T=y;   
  87.         }   
  88.         else   
  89.         {   
  90.             if(x == Left(Parent(x)) )   
  91.             {   
  92.                 x->parent->left=y;   
  93.             }   
  94.             else   
  95.             {   
  96.                 x->parent->right=y;   
  97.             }   
  98.         }   
  99.         y->right=x;   
  100.         x->parent=y;   
  101.     }   
  102.     else   
  103.     {   
  104.         printf(“%s/n”,“can’t execute right rotate due to null left child”);   
  105.     }   
  106.   
  107. }   
  108.   
  109. void InsertFixup(Tree &T, Node *z) //插入结点后, 要维持红黑树四条性质的不变性   
  110. {   
  111.     Node *y;   
  112.     while( Parent(z)->color == RED ) //因为插入的结点是红色的，所以只可能违背性质3,即假如父结点也是红色的，要做调整   
  113.     {   
  114.         if( Parent(Parent(z))->left == Parent(z) ) //如果要插入的结点z是其父结点的左子树   
  115.         {   
  116.             y=Parent(Parent(z))->right; // y设置为z的叔父结点   
  117.             if( y->color == RED ) //case 1: 如果y的颜色为红色，那么将y与z的父亲同时着为黑色，然后把z的   
  118.             { //祖父变为红色，这样子z的祖父结点可能违背性质3,将z上移成z的祖父结点   
  119.                 y->color=BLACK;   
  120.                 z->parent->color=BLACK;   
  121.                 z->parent->parent->color=RED;   
  122.                 z=z->parent->parent;   
  123.             }   
  124.             else   
  125.             {   
  126.                 if( z == z->parent->right ) //case 2: 如果y的颜色为黑色，并且z是z的父母的右结点，则z左旋转，并且将z变为原来z的parent.   
  127.                 {   
  128.                     z=z->parent;   
  129.                     LeftRotate(T, z);   
  130.                 }   
  131.                 z->parent->color=BLACK; //case 3: 如果y的颜色为黑色，并且z是z的父母的左结点，那么将z的   
  132.                 z->parent->parent->color=RED; //父亲的颜色变为黑，将z的祖父的颜色变为红，然后旋转z的祖父   
  133.                 RightRotate(T,z->parent->parent);   
  134.             }   
  135.         }   
  136.         else //与前一种情况对称，要插入的结点z是其父结点的右子树,注释略去   
  137.         {   
  138.             y=Parent(Parent(z))->left;   
  139.             if( y->color == RED)   
  140.             {   
  141.                 z->parent->color=BLACK;   
  142.                 y->color=BLACK;   
  143.                 z->parent->parent->color=RED;   
  144.                 z=z->parent->parent;   
  145.             }   
  146.             else   
  147.             {   
  148.                 if( z == z->parent->left )   
  149.                 {   
  150.                     z=z->parent;   
  151.                     RightRotate(T,z);   
  152.                 }   
  153.                 z->parent->color=BLACK;   
  154.                 z->parent->parent->color=RED;   
  155.                 LeftRotate(T,z->parent->parent);   
  156.             }   
  157.         }   
  158.     }   
  159.     T->color=BLACK; //最后如果上升为T的根的话，把T的颜色设置为黑色   
  160. }   
  161. void Insert(Tree &T, int val) //插入结点   
  162. {   
  163.     if(T == NULL) //初始化工作：如果根尚不存在，那么new一个新结点给根，同时new一个新结点给nil   
  164.     {   
  165.         T=(Tree)malloc(sizeof(Node));   
  166.         nil=(Node*)malloc(sizeof(Node));   
  167.         nil->color=BLACK; //nil的颜色设置为黑   
  168.         T->left=nil;   
  169.         T->right=nil;   
  170.         T->parent=nil;   
  171.         T->value=val;   
  172.         T->color=BLACK; //为了满足性质2,根的颜色设置为黑色   
  173.     }   
  174.     else //如果此树已经不为空，那么从根开始，从上往下查找插入点   
  175.     {   
  176.         Node *x=T; //用x保存当前顶点的父母结点，用p保存当前的结点   
  177.         Node *p=nil;   
  178.         while(x != nil) //如果val小于当前结点的value值，则从左边下去，否则从右边下去   
  179.         {   
  180.             p=x;   
  181.             if(val < x->value )   
  182.             {   
  183.                 x=x->left;   
  184.             }   
  185.             else if(val > x->value)   
  186.             {   
  187.                 x=x->right;   
  188.             }   
  189.             else   
  190.             {   
  191.                 printf(“%s %d/n”,“duplicate value”,val); //如果查找到与val值相同的结点，则什么也不做，直接返回   
  192.                 return;   
  193.             }   
  194.   
  195.         }   
  196.         x=(Node*)malloc(sizeof(Node));   
  197.         x->color=RED; //新插入的结点颜色设置为红色   
  198.         x->left=nil;   
  199.         x->right=nil;   
  200.         x->parent=p;   
  201.         x->value=val;   
  202.         if( val < p->value )   
  203.         {   
  204.             p->left = x;   
  205.         }   
  206.         else   
  207.         {   
  208.             p->right = x;   
  209.         }   
  210.   
  211.         InsertFixup(T, x); //插入后对树进行调整   
  212.   
  213.     }   
  214. }   
  215.   
  216. Node* Successor(Tree &T, Node *x) //寻找结点x的中序后继   
  217. {   
  218.     if( x->right != nil ) //如果x的右子树不为空，那么为右子树中最左边的结点   
  219.     {   
  220.         Node *q=nil;   
  221.         Node *p=x->right;   
  222.         while( p->left != nil )   
  223.         {   
  224.             q=p;   
  225.             p=p->left;   
  226.         }   
  227.         return q;   
  228.     }   
  229.     else //如果x的右子树为空，那么x的后继为x的所有祖先中为左子树的祖先   
  230.     {   
  231.         Node *y=x->parent;   
  232.         while( y != nil && x == y->right )   
  233.         {   
  234.             x=y;   
  235.             y=y->parent;   
  236.         }   
  237.   
  238.         return y;   
  239.     }   
  240. }   
  241.   
  242. void DeleteFixup(Tree &T, Node *x) //删除黑色结点后，导致黑色缺失，违背性质4,故对树进行调整   
  243. {   
  244.     while( x != T && x->color == BLACK ) //如果x是红色，则直接把x变为黑色跳出循环，这样子刚好补了一重黑色,也满足了性质4   
  245.     {   
  246.         if( x == x->parent->left ) //如果x是其父结点的左子树   
  247.         {   
  248.             Node *w=x->parent->right; //设w是x的兄弟结点   
  249.             if( w->color == RED ) //case 1: 如果w的颜色为红色的话   
  250.             {   
  251.                 w->color=BLACK;   
  252.                 x->parent->color=RED;   
  253.                 LeftRotate(T, x->parent);   
  254.                 w=x->parent->right;   
  255.             }   
  256.             if( w->left->color == BLACK && w->right->color == BLACK ) //case 2: w的颜色为黑色，其左右子树的颜色都为黑色   
  257.             {   
  258.                 w->color=RED;   
  259.                 x=x->parent;   
  260.             }   
  261.             else if( w->right->color == BLACK ) //case 3: w的左子树是红色，右子树是黑色的话   
  262.             {   
  263.                 w->color=RED;   
  264.                 w->left->color=BLACK;   
  265.                 RightRotate(T, w);   
  266.                 w=x->parent->right;   
  267.             }   
  268.             w->color=x->parent->color; //case 4: w的右子树是红色   
  269.             x->parent->color=BLACK;   
  270.             w->right->color=BLACK;   
  271.             LeftRotate(T , x->parent);   
  272.   
  273.             x=T;   
  274.         }   
  275.         else //对称情况，如果x是其父结点的右子树   
  276.         {   
  277.             Node *w=x->parent->left;   
  278.             if( w->color == RED )   
  279.             {   
  280.                 w->color=BLACK;   
  281.                 x->parent->color=RED;   
  282.                 RightRotate(T, x->parent);   
  283.                 w=x->parent->left;   
  284.             }   
  285.             if( w->left->color == BLACK && w->right->color == BLACK )   
  286.             {   
  287.                 w->color=RED;   
  288.                 x=x->parent;   
  289.             }   
  290.             else if( w->left->color == BLACK )   
  291.             {   
  292.                 w->color=RED;   
  293.                 w->right->color=BLACK;   
  294.                 LeftRotate(T, w);   
  295.                 w=x->parent->left;   
  296.             }   
  297.             w->color=x->parent->color;   
  298.             x->parent->color=BLACK;   
  299.             w->left->color=BLACK;   
  300.             RightRotate(T , x->parent);   
  301.   
  302.             x=T;   
  303.   
  304.         }   
  305.     }   
  306.     x->color=BLACK;   
  307. }   
  308.   
  309. void Delete(Tree &T, Node *z) //在红黑树T中删除结点z   
  310. {   
  311.     Node *y; //y指向将要被删除的结点   
  312.     Node *x; //x指向将要被删除的结点的唯一儿子   
  313.     if( z->left == nil || z->right == nil ) //如果z有一个子树为空的话，那么将直接删除z,即y指向z   
  314.     {   
  315.         y=z;   
  316.     }   
  317.     else   
  318.     {   
  319.         y=Successor(T, z); //如果z的左右子树皆不为空的话，则寻找z的中序后继y，   
  320.     } //用其值代替z的值，然后将y删除 ( 注意: y肯定是没有左子树的 )   
  321.     if( y->left != nil ) //如果y的左子树不为空，则x指向y的左子树   
  322.     {   
  323.         x=y->left;   
  324.     }   
  325.     else   
  326.     {   
  327.         x=y->right;   
  328.     }   
  329.     x->parent=y->parent; //将原来y的父母设为x的父母，y即将被删除   
  330.     if( y->parent == nil )   
  331.     {   
  332.         T=x;   
  333.     }   
  334.     else   
  335.     {   
  336.         if( y == y->parent->left )   
  337.         {   
  338.             y->parent->left=x;   
  339.         }   
  340.         else   
  341.         {   
  342.             y->parent->right=x;   
  343.         }   
  344.     }   
  345.     if( y != z ) //如果被删除的结点y不是原来将要删除的结点z，   
  346.     { //即只是用y的值来代替z的值，然后变相删除y以达到删除z的效果   
  347.         z->value=y->value;   
  348.     }   
  349.     if( y->color == BLACK ) //如果被删除的结点y的颜色为黑色，那么可能会导致树违背性质4,导致某条路径上少了一个黑色   
  350.     {   
  351.         DeleteFixup(T, x);   
  352.     }   
  353. }   
  354. Node* Search(Tree T, int val)   
  355. {   
  356.     if( T != nil )   
  357.     {   
  358.         if( val < T->value )   
  359.         {   
  360.             Search(T->left, val);   
  361.         }   
  362.         else if ( val > T->value )   
  363.         {   
  364.             Search(T->right,val);   
  365.         }   
  366.         else   
  367.         {   
  368.             return T;   
  369.         }   
  370.     }   
  371. }   
  372.   
  373. void MidTranverse(Tree T)   
  374. {   
  375.     if( T != NULL && T != nil )   
  376.     {   
  377.         MidTranverse(T->left);   
  378.         printf(“%d “,T->value);   
  379.         MidTranverse(T->right);   
  380.     }   
  381.   
  382. } </stdlib.h></stdio.h>  


七、数据结构之线索二叉树

1 基本概念

使用二叉链表无法直接找到每一个节点在某一种遍历序列中的前驱后继，而具有n个节点的二叉链表必定存在n+1个空链域，可以用来存放前驱和后继的指针，并称之为线索（thread），具体的作法：

若节点有左子树，则其左指针指向左孩子；否则另它指向前驱；

若节点有右子树，则其右指针指向右孩子；否则另它指向后继。

为此，二叉链表的节点结构需要增加两个标志域，指明左右链域中的指针是指向左右孩子还是指向前驱后继。

带有线索的二叉链表成为线索链表，相应的二叉树称之为线索二叉树。

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

2. 线索二叉树节点定义

如图所示：

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

对线索链表中结点的约定：在二叉链表的结点中增加两个标志域
若该结点的左子树不空，则Lchild域的指针指向其左子树且左标志域的值为“指针 Link”否则，Lchild域的指针指向其“前驱”，且左标志的值为“线索 Thread”
若该结点的右子树不空，则rchild域的指针指向其右子树，且右标志域的值为 “指针 Link”；否则，rchild域的指针指向其“后继”，且右标志的值为“线索 Thread”。
如此定义的二叉树的存储结构称作“线索链表”。

具体实现如下：


[cpp] 
view plain
 copy

  1. typedef enum { Link, Thread } PointerThr;  
  2. // Link==0:指针，Thread==1:线索  
  3. class BiThrNod {  
  4.              TElemType data;  
  5.              BiThrNode *lchild, *rchild;  // 左右指针  
  6.              PointerThr LTag, RTag;    // 左右标志  
  7. } BiThrNode, *BiThrTree;  



3. 如何建立线索链表？

在中序遍历过程中修改结点的左、右指针域，以保存当前访问结点的“前驱”和“后继”信息。遍历过程中，附设指针pre,  并始终保持指针pre指向当前访问的、指针p所指结点的前驱。形象化的描述如下图所示：

《非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树》

4. 遍历线索链表

由于在线索链表中添加了遍历中得到的前驱”和“后继”的信息，从而简化了遍历的算法
for ( p = firstNode(T); p; p = Succ(p) )
      Visit (p);

寻找某一节点的后继：

ThNode *InorderNext(ThNode *ptr)
{
          ThNode *q;
          If(prt->rtag==Thread) 
                  return(ptr->right);
          else {
    q=ptr->right;
   while(q->ltag==Link)
  q=q->left;
    return q;
}

}

遍历中序线索算法描述：

<1>.寻找中序序列的开始结点
<2>.访问当前结点然后寻找后继
<3>.重复2直到后继为空.

    原文作者：平衡二叉树
    原文地址: https://blog.csdn.net/lcg910978041/article/details/78658231
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞