資料結構 排序二叉樹(BST) 插入刪除查詢 中序遍歷 銷燬(後序遍歷)

gaopengtttt發表於2016-10-29
資料結構排序二叉樹
結構概念如下：

二叉排序樹(binary sort tree):

1、也叫做二叉查詢樹

2、如果他的左子樹不為空，則左子樹上所有結點的

值均小於他的根結構的值

3、如果他的右子樹不為空，則右子樹上所有結點的

值均大於他的根結構的值

4、他的左右子樹分別為二叉排序樹

5、按照二叉樹中序遍歷其返回結果樹有序的

下面就是一顆典型的二叉樹，只是是字母，可以將字母換位字母的順序進行審視，但是它不是平衡二叉樹


排序二叉樹(BST)的優點在於進行資料查詢比較方便，因為他是按照資料來到的順序進行如上的規則進行的
建樹，只要如上的規則進行查詢就能找到需要的資料。但是其缺點也是顯而易見，樹的深度是不可控制的
而且可能極不均勻，考慮 1 2 3 4 5 6 7，這樣的資料建樹全部節點都在左子樹上，級不均勻。那麼給
搜尋資料的效能帶來的較大的影響，所以引入了AVL樹平衡二叉樹，這個在後面再說

關於排序二叉樹BST的各種操作都使用了遞迴演算法，給出遞迴演算法一張我認為很好的圖：


這張圖實際體現了遞迴的真諦 順序呼叫反向返回，這個列子和圖來自小甲魚C視訊也可能來自大話資料結構
上面的程式碼實際上是：

void print()
{
    char a;
    scanf("%c",&a);
      if(a!='#') print();
      if(a!='#') printf("%c",a);
}

關於遞迴的經典 費布那切數列和漢諾塔等都可以瞭解一下；
下面迴歸正題，直接給出程式碼和測試用例。說明程式碼大部分來自大話資料結構，銷燬和中序遍歷是我自己寫的，但是我自己進行了理解。
主要刪除資料比較難，分為3種情況
1、刪除節點的左子樹為空，更改*p = (*p)->rchild;注意這裡的*p代表的是parent->child，所以這樣做就是將父節原來指向刪除節點的指標，指向刪除節點的下一個右孩子
2、刪除節點的右子樹為空，同理更改*p = (*p)->lchild;注意這裡的*p代表的是parent->child，所以這樣做就是將父節原來指向刪除節點的指標，指向刪除節點的下一個左孩子
3、刪除節點左右子樹都不為空，需要進行找到直接前驅或者直接後繼節點進行資料代替。這個就比較複雜直接看程式碼吧
分別進行討論。 
其他操作相對簡單不用再秒素就是遞迴,但是需要注意排序返回資料是用中序遍歷，銷燬樹用的是後序遍歷。
程式碼如下：

點選(此處)摺疊或開啟

  1. 標頭檔案
  2. bstort.h
  3. #include<stdio.h>
  4. typedef int bool;
  5. #define false 0
  6. #define true 1
  7. #define xfree(x) free(x); x = NULL;

  9. typedef struct BiTnode
  10. {
  11.         int data;
  12.         struct BiTnode *lchild,*rchild;
  13. } BiTnode,*BiTree;


  16. bool SearchBst(BiTree T,int key,BiTree *f,BiTree *p);
  17. bool InsertBst(BiTree *T,int key) ;
  18. void Inordervist(const BiTree T);
  19. void BTreedestroy(BiTree tree);
  20. bool DeleteBst(BiTree *T,int key);
  21. bool Delete(BiTree *p);

點選(此處)摺疊或開啟

  1. 實現程式
  2.  bstort.c
  3. #include<stdio.h>
  4. #include<stdlib.h>
  5. #include"bstort.h"
  6. /*
  7.    T = Bst root node
  8.    key = search key
  9.    f = T's parent node,used if search failed save last search node pointer
  10.    if search failed last T is NULL,inital vlaues is NULL,
  11.    is sucuess f is pointer to p's parent poniter,
  12.    p = if sucess p is pointer to find node pointer,if failed is pointer to last
  13.    search node pointer

  15. */

  17. bool SearchBst(BiTree T,int key,BiTree *f,BiTree *p)
  18. {
  19.         if(!T)
  20.         {
  21.                 *p = *f;
  22.                 return false;
  23.         }
  24.         else if(key == T->data)
  25.         {
  26.                 *p = T;
  27.                 return true;
  28.         }
  29.         else if(key < T->data)
  30.         {
  31.                 *f = T;
  32.                 return SearchBst(T->lchild,key,f,p);
  33.         }
  34.         else
  35.         {
  36.                 *f = T;
  37.                 return SearchBst(T->rchild,key,f,p);
  38.         }
  39. }

  41. /*
  42.    T = Bst root node
  43.    key = key to insert
  44.    */
  45. bool InsertBst(BiTree *T,int key)
  46. {
  47.         BiTree p = NULL ,s = NULL ,f=NULL;
  48.         if(!SearchBst(*T,key,&f,&p)) //init NULL,KEY,NULL,&P=NULL
  49.         {
  50.                 s = (BiTree)calloc(1,sizeof(BiTnode));
  51.                 s->data =key;
  52.                 s->lchild = s->rchild = NULL;

  54.                 if(!p)
  55.                 {
  56.                         printf("Create Tree with key:%d\n",key);
  57.                         *T = s; //create Bst one node
  58.                 }
  59.                 else if(key < p->data)
  60.                 {
  61.                         printf("Insert Key To Tree(left):%d\n",key);
  62.                         p->lchild = s;
  63.                 }
  64.                 else
  65.                 {
  66.                         printf("Insert Key To Tree(right):%d\n",key);
  67.                         p->rchild = s;
  68.                 }
  69.                 return true;
  70.         }
  71.         else
  72.         {
  73.                 return false;
  74.         }
  75. }
  76. /*
  77. inorder traversal method
  78. */

  80. void Inordervist(const BiTree T)
  81. {
  82.         if(T)
  83.         {
  84.                 Inordervist(T->lchild);
  85.                 printf("%d\n",T->data);
  86.                 Inordervist(T->rchild);
  87.         }
  88. }

  90. /*
  91. postorder traversal method to destroy tree
  92. */

  94. void BTreedestroy(BiTree T)
  95. {

  97.         if(T)
  98.         {
  99.         BTreedestroy(T->lchild);
  100.         BTreedestroy(T->rchild);
  101.         printf("Delete node for Key%d\n",T->data);
  102.         xfree(T);
  103.         }
  104. }


  107. bool DeleteBst(BiTree *T,int key)//use **p *p is parent->child,here is very import
  108. {
  109.         if(!*T)//
  110.         {
  111.                 printf("no delete data %d find\n........\n",key);
  112.                 return true;
  113.         }
  114.         else
  115.         {
  116.                 if(key == (*T)->data)
  117.                 {
  118.                         return Delete(T);
  119.                 }
  120.                 else if(key < (*T)->data)
  121.                 {
  122.                         return DeleteBst(&(*T)->lchild,key);//here use lchild pointer's address
  123.                 }
  124.                 else
  125.                 {
  126.                         return DeleteBst(&(*T)->rchild,key);
  127.                 }
  128.         }
  129. }

  131. bool Delete(BiTree *p)//use **p *p is parent->child,here is very import
  132. {
  133.         BiTree q,s;

  135.         printf("delete data :%d\n........\n",(*p)->data);
  136.         if((*p)->rchild == NULL)//right node is NULL
  137.         {
  138.                 q = *p;
  139.                 *p = (*p)->lchild;
  140.                 xfree(q);
  141.         }
  142.         else if((*p)->lchild ==NULL)//leaf node is NULL
  143.         {
  144.                 q = *p;
  145.                 *p = (*p)->rchild;
  146.                 xfree(q);
  147.         }
  148.         else //exp:use ...20 30 50 (60 delete)... use 50 replace 60 ,use replace not free find node
  149.         {
  150.                 q = *p;
  151.                 //---------------
  152.                 s = (*p)->lchild;
  153.                 while(s->rchild) //if s->rchild is NULL q=*p mean (*p)->lchild s have no right node
  154.                 {
  155.                         q = s;
  156.                         s = s->rchild;
  157.                 }
  158.                 (*p)->data = s->data;

  160.                 /*-------------- here find near delete node small data,frist find lchild then find
  161.                 all small data root node then find last right node this is require data*/

  163.                 if(q!=*p) //if (*p)->lchild s have right node
  164.                 {
  165.                         q->rchild =s->lchild;
  166.                 }
  167.                 else // if (*p)->lchild s have no right node
  168.                 {
  169.                         q->lchild = s ->lchild;
  170.                 }
  171.                 xfree(s);//free find last right node,beacuse it's data used for find node
  172.         }
  173. }





點選(此處)摺疊或開啟

  1. 測試用例和主函式
  2. main.c
  3. #include<stdio.h>
  4. #include"bstort.h"


  7. int main(void)
  8. {
  9.         BiTree root = NULL;
  10.         InsertBst(&root,10);
  11.         InsertBst(&root,20);
  12.         InsertBst(&root,40);
  13.         InsertBst(&root,5);
  14.         InsertBst(&root,1);
  15.         InsertBst(&root,-1);
  16.         InsertBst(&root,-20);
  17.         InsertBst(&root,100);
  18.         printf("Use inorder traversal method:\n");
  19.         Inordervist(root);
  20.         DeleteBst(&root,30);
  21.         DeleteBst(&root,10);
  22.         printf("Use inorder traversal method:\n");
  23.         Inordervist(root);
  24.         printf("Use postorder traversal method destroy Bst:\n");
  25.         BTreedestroy(root);
  26. }

結構如下：
Create Tree with key:10
Insert Key To Tree(right):20
Insert Key To Tree(right):40
Insert Key To Tree(left):5
Insert Key To Tree(left):1
Insert Key To Tree(left):-1
Insert Key To Tree(left):-20
Insert Key To Tree(right):100
Use inorder traversal method:
-20
-1
1
5
10
20
40
100
no delete data 30 find
........
delete data :10
........
Use inorder traversal method:
-20
-1
1
5
20
40
100
Use postorder traversal method destroy Bst:
Delete node for Key-20
Delete node for Key-1
Delete node for Key1
Delete node for Key100
Delete node for Key40
Delete node for Key20
Delete node for Key5

這裡首先演示了建樹，然後演示了中序遍歷返回有序的結果，然後刪除一個不包含的資料30，
然後刪除一個包含的資料10，然後再次進行中序遍歷，最後使用後續遍歷刪除。
可以看到結果如我們希望的。

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/7728585/viewspace-2127320/，如需轉載，請註明出處，否則將追究法律責任。

相關文章