数据结构——二叉搜索树（Binary Search Tree）

二叉树（Binary Tree）的基础下

每个父节点下 左节点小，右节点大。

 

节点的插入：

　　若root==NULL则root=newnode

　　否则不断与节点值比较，较小则向左比较，较大则向右比较。

完整代码：

 1 stnode *insert(const string &item)

 2 {

 3     stnode *t=root,*newnode,*parent=NULL;

 4     while(t!=NULL)

 5     {

 6         parent=t;

 7         if(item==t->nodeValue)

 8             return NULL;

 9         else if(item<t->nodeValue)

10             t=t->left;

11         else

12             t=t->right;

13     }

14     newnode=creatAVLNode(item,NULL,NULL,parent);

15     if(parent==NULL) 

16         root=newnode;

17     else if(item>parent->nodeValue)

18         parent->right=newnode;

19     else 

20         parent->left=newnode;

21         treeSize++;

22 }//返回节点值是为之后的其他操作 也可以是void

View Code

此处的insert返回类型可以为pair对

　　pair<stree<T>::iterator,bool>insert(const T&item);

　　insert.first　即为迭代器的值　

　　// iterator=tree.begin()++ 树的最左节点（min），从小到大遍历，往右边的最左走。

　　insert.second　　即为bool值

 

节点的删除：

*每一种情况下都要讨论是否为root。

1、叶子节点

　　t->parent->left/right=NULL;

　　delete t;

2、只有左/右子树

　　直接拿子节点填补空缺，成为t->parent的子节点。

3、同时有左右子树

　　选择左子树的最右节点或者右子树的最左节点填补空缺。

　　注意讨论替换节点是否有子树以及父节点的不同情况。

　　若替换节点无子节点，则1步骤无，使t->parent->left=NULL;

　　若替换节点的父节点即为需要删除的节点 省略步骤1&4 即

完整代码：

  1 void remove(const string &item)

  2 {

  3     stnode *t=search(item);    //查找需要删除的节点值 search函数返回类型为stnode

  4     if(t==NULL) return;

  5     

  6     //leaf node

  7     else if(t->left==NULL&&t->right==NULL)

  8     {

  9         if(t==root)

 10             root=NULL;

 11         else if(t->nodeValue>t->parent->nodeValue)

 12             t->parent->right=NULL;

 13         else 

 14             t->parent->left=NULL;

 15     }

 16     //only left or right

 17     else if(t->left==NULL)

 18     {

 19         if(t==root)

 20         {

 21             t->right->parent=NULL;

 22             root=t->right;

 23         }

 24         else if(t->nodeValue>t->parent->nodeValue)

 25             t->parent->right=t->right;

 26         else 

 27             t->parent->left=t->right;

 28         t->right->parent=t->parent;

 29     }

 30     else if(t->right==NULL)

 31     {

 32         if(t==root)

 33         {

 34             t->left->parent=NULL;

 35             root=t->left;

 36         }

 37         else if(t->nodeValue>t->parent->nodeValue)

 38             t->parent->right=t->left;

 39         else 

 40             t->parent->left=t->left;

 41         t->left->parent=t->parent;

 42     }

 43     //left && right

 44     else

 45     {

 46         AVLnode *r=t;

 47         if(t==root)

 48         {

 49             r=r->right;

 50             while(r->left!=NULL)

 51                 r=r->left;

 52 

 53             r->left=t->left;

 54             t->left->parent=r;

 55             if(r->right==NULL&&r->parent!=root)

 56             {

 57                 r->right=t->right;

 58                 t->right->parent=r;

 59                 r->parent->left=NULL;

 60             }

 61             else if(r->parent!=root)

 62             {

 63                 r->parent->left=r->right;

 64                 r->right->parent=r->parent;

 65                 r->right=t->right;

 66                 t->right->parent=r;

 67             }

 68 

 69             r->parent=NULL;

 70             root=r;

 71 

 72         }

 73 

 74         else if(t->nodeValue>t->parent->nodeValue)

 75         {

 76             r=r->right;

 77             while(r->left!=NULL)

 78                 r=r->left;

 79 

 80             if(r->parent!=t)

 81             {    

 82                 if(r->right==NULL)

 83                     r->parent->left=NULL;

 84                 else 

 85                 {

 86                     r->right->parent=r->parent;

 87                     r->parent->left=r->right;

 88                 }

 89     

 90                 r->right=t->right;

 91                 t->right->parent=r;

 92                 

 93                 r->parent=t->parent;

 94                 t->parent->right=r;

 95                 r->left=t->left;

 96                 t->left->parent=r;

 97             }

 98             else

 99             {

100                 r->parent=t->parent;

101                 t->parent->right=r;

102                 r->left=t->left;

103                 t->left->parent=r;

104             }

105             

106         }

107         else 

108         {

109             r=r->right;

110             while(r->left!=NULL)

111                 r=r->left;

112 

113             if(r->parent!=t)

114             {    

115                 if(r->right==NULL)

116                     r->parent->left=NULL;

117                 else 

118                 {

119                     r->right->parent=r->parent;

120                     r->parent->left=r->right;

121                 }

122     

123                 r->right=t->right;

124                 t->right->parent=r;

125                 

126                 r->parent=t->parent;

127                 t->parent->left=r;

128                 r->left=t->left;

129                 t->left->parent=r;

130             }

131             else

132             {

133                 r->parent=t->parent;

134                 t->parent->left=r;

135                 r->left=t->left;

136                 t->left->parent=r;

137             }

138             

139         }

140     }

141     treeSize--;

142     delete t;

143 }

View Code