《算法导论》读书笔记

Posted 2020-10-25 AlanTu

《算法导论》读书笔记之第12章 二叉查找树

摘要：

　　本章介绍了二叉查找树的概念及操作。主要内容包括二叉查找树的性质，如何在二叉查找树中查找最大值、最小值和给定的值，如何找出某一个元素的前驱和后继，如何在二叉查找树中进行插入和删除操作。在二叉查找树上执行这些基本操作的时间与树的高度成正比，一棵随机构造的二叉查找树的期望高度为O(lgn)，从而基本动态集合的操作平均时间为θ(lgn)。

1、二叉查找树

　　二叉查找树是按照二叉树结构来组织的，因此可以用二叉链表结构表示。二叉查找树中的关键字的存储方式满足的特征是：设x为二叉查找树中的一个结点。如果y是x的左子树中的一个结点，则key[y]≤key[x]。如果y是x的右子树中的一个结点，则key[x]≤key[y]。根据二叉查找树的特征可知，采用中根遍历一棵二叉查找树，可以得到树中关键字有小到大的序列。http://www.cnblogs.com/Anker/archive/2013/01/27/2878594.html介绍了二叉树概念及其遍历。一棵二叉树查找及其中根遍历结果如下图所示：

书中给出了一个定理：如果x是一棵包含n个结点的子树的根，则其中根遍历运行时间为θ(n)。

问题：二叉查找树性质与最小堆之间有什么区别？能否利用最小堆的性质在O(n)时间内，按序输出含有n个结点的树中的所有关键字？

2、查询二叉查找树

　　二叉查找树中最常见的操作是查找树中的某个关键字，除了基本的查询，还支持最大值、最小值、前驱和后继查询操作，书中就每种查询进行了详细的讲解。

（1）查找SEARCH

　　在二叉查找树中查找一个给定的关键字k的过程与二分查找很类似，根据二叉查找树在的关键字存放的特征，很容易得出查找过程：首先是关键字k与树根的关键字进行比较，如果k大比根的关键字大，则在根的右子树中查找，否则在根的左子树中查找，重复此过程，直到找到与遇到空结点为止。例如下图所示的查找关键字13的过程：（查找过程每次在左右子树中做出选择，减少一半的工作量）

书中给出了查找过程的递归和非递归形式的伪代码：

1 TREE_SEARCH(x,k)
2   if x=NULL or k=key[x]
3       then return x
4   if(k<key[x])
5       then return TREE_SEARCH(left[x],k)
6    else
7       then return TREE_SEARCH(right[x],k)

1 ITERATIVE_TREE_SEARCH(x,k)
2   while x!=NULL and k!=key[x]
3       do if k<key[x]
4               then x=left[x]
5            else
6               then x=right[x]
7    return x

（2）查找最大关键字和最小关键字

　　根据二叉查找树的特征，很容易查找出最大和最小关键字。查找二叉树中的最小关键字：从根结点开始，沿着各个节点的left指针查找下去，直到遇到NULL时结束。如果一个结点x无左子树，则以x为根的子树中，最小关键字就是key[x]。查找二叉树中的最大关键字：从根结点开始，沿着各个结点的right指针查找下去，直到遇到NULL时结束。书中给出了查找最大最小关键字的伪代码：

1 TREE_MINMUM(x)
2    while left[x] != NULL
3       do x=left[x]
4    return x

1 1 TREE_MAXMUM(x)
2 2    while right[x] != NULL
3 3         do x= right[x]
4 4     return x

（3）前驱和后继

　　给定一个二叉查找树中的结点，找出在中序遍历顺序下某个节点的前驱和后继。如果树中所有关键字都不相同，则某一结点x的前驱就是小于key[x]的所有关键字中最大的那个结点，后继即是大于key[x]中的所有关键字中最小的那个结点。根据二叉查找树的结构和性质，不用对关键字做任何比较，就可以找到某个结点的前驱和后继。

　　查找前驱步骤：先判断x是否有左子树，如果有则在left[x]中查找关键字最大的结点，即是x的前驱。如果没有左子树，则从x继续向上执行此操作，直到遇到某个结点是其父节点的右孩子结点。例如下图查找结点7的前驱结点6过程：

　　查找后继步骤：先判断x是否有右子树，如果有则在right[x]中查找关键字最小的结点，即使x的后继。如果没有右子树，则从x的父节点开始向上查找，直到遇到某个结点是其父结点的左儿子的结点时为止。例如下图查找结点13的后继结点15的过程：

书中给出了求x结点后继结点的伪代码:

1 TREE_PROCESSOR(x)
2     if right[x] != NULL
3         then return TREE_MINMUM(right(x))
4     y=parent[x]
5     while y!= NULL and x ==right[y]
6            do x = y
7                y=parent[y]
8     return y

定理：对一棵高度为h的二叉查找，动态集合操作SEARCH、MINMUM、MAXMUM、SUCCESSOR、PROCESSOR等的运行时间均为O(h)。

3、插入和删除

　　插入和删除会引起二叉查找表示的动态集合的变化，难点在在插入和删除的过程中要保持二叉查找树的性质。插入过程相当来说要简单一些，删除结点比较复杂。

（1）插入

　　插入结点的位置对应着查找过程中查找不成功时候的结点位置，因此需要从根结点开始查找带插入结点位置，找到位置后插入即可。下图所示插入结点过程：

书中给出了插入过程的伪代码：

 1 TREE_INSERT(T,z)
 2     y = NULL;
 3     x =root[T]
 4     while x != NULL
 5         do y =x
 6             if key[z] < key[x]
 7                  then x=left[x]
 8                  else  x=right[x]
 9      parent[z] =y
10      if y=NULL
11         then root[T] =z
12         else if key[z]>key[y]
13                    then  keft[y]  = z
14                    else   right[y] =z

插入过程运行时间为O(h)，h为树的高度。

（2）删除

　　从二叉查找树中删除给定的结点z，分三种情况讨论：

<1>结点z没有左右子树，则修改其父节点p[z]，使其为NULL。删除过程如下图所示：

<2>如果结点z只有一个子树（左子树或者右子树），通过在其子结点与父节点建立一条链来删除z。删除过程如下图所示：

<3>如果z有两个子女，则先删除z的后继y（y没有左孩子），在用y的内容来替代z的内容。

书中给出了删除过程的伪代码：

 1 TREE_DELETE(T,z)
 2     if left[z] ==NULL or right[z] == NULL
 3        then y=z
 4        else  y=TREE_SUCCESSOR(z)
 5    if left[y] != NULL
 6        then x=left[y]
 7        else  x=right[y]
 8    if x!= NULL
 9        then parent[x] = parent[y]
10    if p[y] ==NULL
11       then root[T] =x
12       else if y = left[[prarnt[y]]
13                   then left[parent[y]] = x
14                   else  right[parent[y]] =x
15     if y!=z
16         then key[z] = key[y]
17               copy y\'s data into z
18      return y        

定理：对高度为h的二叉查找树，动态集合操作INSERT和DELETE的运行时间为O(h)。

4、实现测试

　　采用C++语言实现一个简单的二叉查找树，支持动态集合的基本操作：search、minmum、maxmum、predecessor、successor、insert和delete。设计的二叉查找树结构如下所示：

 1 template <class T>
 2 class  BinarySearchTreeNode
 3 {
 4 public:
 5     T elem;
 6     struct BinarySearchTreeNode<T> *parent;
 7     struct BinarySearchTreeNode<T>* left;
 8     struct BinarySearchTreeNode<T>* right;
 9 };
10 
11 template <class T>
12 class BinarySearchTree
13 {
14 public:
15     BinarySearchTree();
16     void tree_insert(const T& elem);
17     int  tree_remove(const T& elem );
18     BinarySearchTreeNode<T>* tree_search(const T& elem)const;
19     T tree_minmum(BinarySearchTreeNode<T>* root)const;
20     T tree_maxmum(BinarySearchTreeNode<T>* root)const;
21     T tree_successor(const T& elem) const;
22     T tree_predecessor(const T& elem)const;
23     int empty() const;
24     void inorder_tree_walk()const;
25     BinarySearchTreeNode<T>* get_root()const {return root;}
26 private:
27     BinarySearchTreeNode<T>* root;
28 };

 完整程序如下所示：

  1 #include <iostream>
  2 #include <stack>
  3 #include <cstdlib>
  4 using namespace std;
  5 
  6 template <class T>
  7 class  BinarySearchTreeNode
  8 {
  9 public:
 10     T elem;
 11     struct BinarySearchTreeNode<T> *parent;
 12     struct BinarySearchTreeNode<T>* left;
 13     struct BinarySearchTreeNode<T>* right;
 14 };
 15 
 16 template <class T>
 17 class BinarySearchTree
 18 {
 19 public:
 20     BinarySearchTree();
 21     void tree_insert(const T& elem);
 22     int  tree_remove(const T& elem );
 23     BinarySearchTreeNode<T>* tree_search(const T& elem)const;
 24     T tree_minmum(BinarySearchTreeNode<T>* root)const;
 25     T tree_maxmum(BinarySearchTreeNode<T>* root)const;
 26     T tree_successor(const T& elem) const;
 27     T tree_predecessor(const T& elem)const;
 28     int empty() const;
 29     void inorder_tree_walk()const;
 30     BinarySearchTreeNode<T>* get_root()const {return root;}
 31 private:
 32     BinarySearchTreeNode<T>* root;
 33 };
 34 
 35 template <class T>
 36 BinarySearchTree<T>::BinarySearchTree()
 37 {
 38     root = NULL;
 39 }
 40 
 41 template <class T>
 42 void BinarySearchTree<T>::tree_insert(const T& elem)
 43 {
 44     if(!empty())
 45     {
 46         BinarySearchTreeNode<T> *pnode = root;
 47         BinarySearchTreeNode<T> *qnode = NULL;
 48         BinarySearchTreeNode<T> *newnode = new BinarySearchTreeNode<T>;
 49         newnode->elem = elem;
 50         newnode->parent = NULL;
 51         newnode->left = NULL;
 52         newnode->right = NULL;
 53         while(pnode)
 54         {
 55             qnode = pnode;
 56             if(pnode->elem > elem)
 57                 pnode = pnode->left;
 58             else
 59                 pnode = pnode->right;
 60         }
 61         if(qnode->elem > elem)
 62             qnode->left = newnode;
 63         else
 64             qnode->right = newnode;
 65         newnode->parent = qnode;
 66     }
 67     else
 68     {
 69         root = new BinarySearchTreeNode<T>;
 70         root->elem = elem;
 71         root->parent =NULL;
 72         root->left = NULL;
 73         root->right = NULL;
 74     }
 75 }
 76 
 77 template <class T>
 78 int BinarySearchTree<T>::tree_remove(const T&elem)
 79 {
 80     BinarySearchTreeNode<T> *pnode;
 81     BinarySearchTreeNode<T> *parentnode,*snode;
 82     pnode = tree_search(elem);
 83     if(pnode != NULL)
 84     {
 85        parentnode = pnode->parent;
 86        if(pnode->right == NULL || pnode->left == NULL)
 87        {
 88             if(pnode->right != NULL)
 89             {
 90                 if(parentnode->left == pnode)
 91                     parentnode->left = pnode->right;
 92                 if(parentnode->right == pnode)
 93                     parentnode->right = pnode->right;
 94                 pnode->right->parent = parentnode;
 95             }
 96             else if(pnode->left != NULL)
 97             {
 98                 if(parentnode->left == pnode)
 99                     parentnode->left = pnode->left;
100                 if(parentnode->right == pnode)
101                     parentnode->right = pnode->left;
102                 pnode->left->parent = parentnode;
103             }
104             else
105             {
106                 if(parentnode->left == pnode)
107                     parentnode->left = NULL;
108                 if(parentnode->right == pnode)
109                     parentnode->right = NULL;
110             }
111             delete pnode;
112        }
113        else
114        {
115            snode = tree_search(tree_successor(pnode->elem));
116            pnode->elem = snode->elem;
117            if(snode->parent->left == snode)
118            {
119                snode->parent->left = snode->right;
120                snode->right->parent = snode->parent->left;
121            }
122            if(snode->parent->right == snode)
123            {
124                snode->parent->right = snode->right;
125                snode->right->parent = snode->parent->right;
126            }
127            delete snode;
128        }
129        return 0;
130     }
131     return -1;
132 }
133 template <class T>
134 BinarySearchTreeNode<T>* BinarySearchTree<T>::tree_search(const T& elem)const
135 {
136     BinarySearchTreeNode<T> *pnode = root;
137     while(pnode)
138     {
139         if(pnode->elem == elem)
140             break;
141         else if(pnode->elem > elem)
142             pnode = pnode->left;
143         else
144             pnode = pnode->right;
145     }
146     return pnode;
147 }
148 
149 template <class T>
150 T BinarySearchTree<T>::tree_minmum(BinarySearchTreeNode<T>* root)const
151 {
152     BinarySearchTreeNode<T> *pnode = root;
153     if(pnode->left)
154     {
155         while(pnode->left)
156             pnode = pnode->left;
157     }
158     return pnode->elem;
159 }
160 
161 template <class T>
162 T BinarySearchTree<T>::tree_maxmum(BinarySearchTreeNode<T>* root)const
163 {
164     BinarySearchTreeNode<T> *pnode = root;
165     if(pnode->right)
166     {
167         while(pnode->right)
168             pnode = pnode->right;
169     }
170     return pnode->elem;
171 }
172 
173 template <class T>
174 T BinarySearchTree<T>::tree_successor(const T& elem) const
175 {
176     BinarySearchTreeNode<T>* pnode = tree_search(elem);
177     BinarySearchTreeNode<T>* parentnode;
178     if(pnode != NULL)
179     {
180         if(pnode->right)
181             return tree_minmum(pnode->right);
182         parentnode = pnode->parent;
183         while(parentnode && pnode == parentnode->right)
184         {
185             pnode = parentnode;
186             parentnode = parentnode->parent;
187         }
188         if(parentnode)
189             return parentnode->elem;
190         else
191             return T();
192     }
193     return T();
194 }
195 template <class T>
196 T BinarySearchTree<T>::tree_predecessor(const T& elem)const
197 {
198     BinarySearchTreeNode<T>* pnode = tree_search(elem);
199     BinarySearchTreeNode<T>* parentnode;
200     if(pnode != NULL)
201     {
202         if(pnode->right)
203             return tree_maxmum(pnode->right);
204         parentnode = pnode->parent;
205         while(parentnode && pnode == parentnode->left)
206         {
207             pnode = parentnode;
208             parentnode = pnode->parent;
209         }
210         if(parentnode)
211             return parentnode->elem;
212         else
213             return T();
214     }
215     return T();
216 }
217 
218 template <class T>
219 int BinarySearchTree<T>::empty() const
220 {
221     return (NULL == root);
222 }
223 
224 template <class T>
225 void BinarySearchTree<T>::inorder_tree_walk()const
226 {
227     if(NULL != root)
228      {
229          stack<BinarySearchTreeNode<T>*> s;
230          BinarySearchTreeNode<T> *ptmpnode;
231          ptmpnode = root;
232          while(NULL != ptmpnode || !s.empty())
233          {
234              if(NULL != ptmpnode)
235              {
236                  s.push(ptmpnode);
237                  ptmpnode = ptmpnode->left;
238              }
239              else
240              {
241                  ptmpnode = s.top();
242                  s.pop();
243                  cout<<ptmpnode->elem<<" ";
244                  ptmpnode = ptmpnode->right;
245              }
246          }
247      }
248 }
249 int main()
250 {
251     BinarySearchTree<int> bstree;
252     BinarySearchTreeNode<int>* ptnode,*proot;
253     bstree.tree_insert(32);
254     bstree.tree_insert(21);
255     bstree.tree_insert(46);
256     bstree.tree_insert(54);
257     bstree.tree_insert(16);
258     bstree.tree_insert(38);
259     bstree.tree_insert(70);
260     cout<<"inorder tree walk is: ";
261     bstree.inorder_tree_walk();
262     proot = bstree.get_root();
263     cout<<"\\nmax value is: "<<bstree.tree_maxmum(proot)<<endl;
264     cout<<"min value is: "<<bstree.tree_minmum(proot)<<endl;
265     ptnode = bstree.tree_search(38);
266     if(ptnode)
267         cout<<"the element 38 is exist in the binary tree.\\n";
268     else
269         cout<<"the element 38 is not exist in the binary tree.\\n";
270     cout<<"the successor of 38 is: "<<bstree.tree_successor(38)<<endl;
271     cout<<"the predecessor of 38 is:"<<bstree.tree_predecessor(38)<<endl;
272     if(bstree.tree_remove(46) == 0)
273         cout<<"delete 46 successfully"<<endl;
274     else
275         cout<<"delete 46 failed"<<endl;
276     cout<<"inorder tree walk is: ";
277     bstree.inorder_tree_walk();
278     exit(0);
279 }

程序测试结果如下所示：

　　二叉树实现时候添加了一个父结点指针，方便寻找给定结点的前驱和后继。二叉树中删除操作实现比较复杂，需要分类讨论，我分三种情况进行讨论，程序写的有些繁琐，可以进行优化。优化后的代码如下：

 1 template <class T>
 2 int BinarySearchTree<T>::tree_delete(const T& elem)
 3 {
 4     //找到该元素对应的结点
 5     BinarySearchTreeNode<T>* pnode = tree_search(elem);
 6     if(NULL != pnode)
 7     {
 8         BinarySearchTreeNode<T> *qnode,*tnode;
 9         //判断结点是否有左右孩子
10         if(pnode->left == NULL || pnode->right == NULL)
11             qnode = pnode;   //有一个左孩子或者一个右孩子和没有左右孩子
12         else
13             qnode = tree_search(tree_successor(elem)); //有左右孩子
14         if(NULL != qnode->left)
15             tnode = qnode->left;
16         else
17             tnode = qnode->right;
18         if(NULL != tnode)
19             tnode->parent = qnode->parent;
20         if(qnode->parent == NULL)
21             root = tnode;
22         else
23             if(qnode == qnode->parent->left)
24                 qnode->parent->left = tnode;
25             else
26                 qnode->parent->right = tnode;
27         if(qnode != pnode)
28             pnode->elem = qnode->elem;  //将后继结点的值复制到要删除的结点的值
29         delete qnode;
30         return 0;
31     }
32     return -1;
33 }

5、随机构造二叉查找树

　　二叉查找上各种基本操作的运行时间都是O(h)，h为树的高度。但是在元素插入和删除过程中，树的高度会发生改变。如果n个元素按照严格增长的顺序插入，那个构造出的二叉查找树的高度为n-1。例如按照先后顺序插入7、15、18、20、34、46、59元素构造二叉查找树，二叉查找树结构如下所示：

 

 

 

《算法导论》读书笔记之第13章 红黑树

摘要：

　　红黑树是一种二叉查找树，但在每个结点上增加了一个存储位表示结点的颜色，可以是RED或者BLACK。通过对任何一条从根到叶子的路径上各个着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。本章主要介绍了红黑树的性质、左右旋转、插入和删除。重点分析了在红黑树中插入和删除元素的过程，分情况进行详细讨论。一棵高度为h的二叉查找树可以实现任何一种基本的动态集合操作，如SEARCH、PREDECESSOR、SUCCESSOR、MIMMUM、MAXMUM、INSERT、DELETE等。当二叉查找树的高度较低时，这些操作执行的比较快，但是当树的高度较高时，这些操作的性能可能不比用链表好。红黑树（red-black tree）是一种平衡的二叉查找树，它能保证在最坏情况下，基本的动态操作集合运行时间为O(lgn)。本章内容有些复杂，看了两天，才大概清楚其插入和删除过程，日后需要经常回顾，争取完全消化掉。红黑树的用途非常广泛，例如STL中的map就是采用红黑树实现的，效率非常之高，有机会可以研究一下STL的源代码。

1、红黑树的性质

　　红黑树中的每个结点包含五个域：color、key、left、right和parent。如果某结点没有一个子结点或父结点，则该结点相应的指针parent域包含值为NIL（NIL并是是空指针，此处有些迷惑，一会解释）。把NIL视为指向红黑树的外结点（叶子）的指针，而把带关键字的结点视为红黑树的内结点。红黑树结点结构如下所示：

 1 #define RED  0
 2 #define BLACK 1
 3 struct RedBlackTreeNode
 4 { 
 5     T key;
 6     struct RedBlackTreeNode * parent;
 7     struct RedBlackTreeNode * left;
 8     struct RedBlackTreeNode * right;
 9     int color;
10 };

红黑树的性质如下：

（1）每个结点或是红色，或是黑色。

（2）根结点是黑色。

（3）每个叶子结点（NIL）是黑色。

（4）如果有一个结点是红色，则它的两个儿子都是黑色。

（5）对每个结点，从该结点到其孙子结点的所有路径上包含相同数目的黑色结点。

如下图是一棵红黑树：

从图可以看出NIL不是空指针，而是一个叶子结点。实际操作的时候可以将NIL视为哨兵，这样便于对黑红色进行操作。红黑树的操作主要是对内部结点操作，因为内部结点存储了关键字的值。书中为了便于讨论，忽略了叶子结点的，如是上图红黑树变成如下图所示：

　　书中给出了黑高度的概念：从某个结点x出发（不包含该结点）到达一个叶子结点的任意一条路径上，黑色结点的个数称为该结点的黑高度。由红黑树的性质（5）可知，从该结点出发的所有下降路径都有相同的黑色结点个数。红黑树的黑高度定义为其根结点的黑高度。

　　书中给出了一个引理来说明为什么红黑树是一种好的查找树，并对引理进行了证明（采用归纳法进行证明的，需要很强的归纳推理知识，正是我的不足之处，看书的痛苦在于此）。

引理：一棵有n个内结点的红黑树的高度之多为2lg(n+1)。

2、旋转

　　在红黑树上进行结点插入和删除操作时，会改变树的结构形状，导致结果可能不满足了红黑树的某些性质，为了保证每次插入和删除操作后，仍然能报维持红黑树的性质，需要改变树中某些结点的颜色和指针结构。其中的指针结构的改变通过旋转完成的。书中给出了两种旋转：左旋转和右旋转。如下图是旋转过程：

　　从图可以得出左右旋转的过程，假设对某个结点x进行左旋转，y是x的右孩子，则左旋转过程为：以x和y之间的链为“支轴”进行的，使得x的右孩子为y的左孩子，y的父节点为x的父节点，y的左孩子为x。书中给出了左旋转的伪代码如下：

 1 LEFT_ROTATE(T,x)
 2    y = right[x]   //获取右孩子
 3    rihgt[x] = left[y]  //设置x的右孩子为y的左孩子
 4    if left[y] != NIL
 5        then parent[left[x]] = x
 6     parent[y] = parent[x]  //设置y的父节点为x的父节点
 7     if parent[x] == NIL
 8        then root[T] = y
 9        else if x==left[parent[x]
10               then left[parent[x]] = y
11               else  right[[parent[x]] = y
12     left[y] = x  //设置y的左孩子为x
13     parent[x] =y
14 
15    

假设对某个结点y进行右旋转，x是y的左孩子，则左旋转过程为：y的左孩子设置为x的右孩子，将x的父节点设置为y的父节点，x的右孩子设置为y。书中并没有给出右旋转的伪代码，参照左旋转的伪代码很容易实现：

 1  RIGHT_ROTATE(T,y)
 2      x = left[y]    //获取左孩子
 3      left[y] = right[x] //设置y的左孩子为x的右孩子
 4      if right[x] != NIL
 5         then parent[right[x]] = y
 6      parent[x] = parent[y]  //设为x的父节点为y的父结点
 7      if parent[y] == NIL
 8          then root = x
 9          else if y== left[parent[y]]
10                then left[parent[y]] = x
11                else  right[parent[y]] = x
12      right[x] = y //设置x的右孩子为y
13      parent[y] = x

 为了更好的理解旋转操作，书中给出了一个左旋转的例如，如下图所示：

3、插入

　　红黑树插入一个新结点的过程RB_INSERT是在二叉查找树插入过程的基础上改进的，先按照二叉排序的插入过程插入到红黑树中，然后将新插入的结点标记为红色（疑问：为什么是红色，而不是黑色呢？），然后调用一个辅助的过程RB_INSERT_FIXUP来调整结点并重新着色，使得满足红黑树的性质。关于二叉查找树的插入过程可以参考上一篇日志：http://www.cnblogs.com/Anker/archive/2013/01/28/2880581.html。书中给出了RB_INSERT的伪代码：

 1 RB_INSERT(T,z)
 2   y = NIL
 3   x =root(T)
 4   while x != NIL
 5        do y=x
 6            if key[z]<key[x]
 7              then x=left[x]
 8              else  x=right[x]
 9   parent[z] = y
10   if y =NIL
11      then root =z
12      else if key[z] < key[y]
13             then left[y] =z
14             else  right[y] =z
15    left[z] = NIL
16    right[z] =NIL
17    color[z] = RED  //新插入结点标记为红色
18    RB_INSERT_FIXUP(T,z)  //进行调整，使得满足红黑树性质以上是关于《算法导论》读书笔记的主要内容，如果未能解决你的问题，请参考以下文章
 
 《算法导论》读书笔记
 《算法导论》读书笔记
 《算法导论》读书笔记
 《算法导论》读书笔记
 算法导论读书笔记-第十三章-红黑树
 《算法导论》读书笔记