二叉树的建立、节点查找以及节点删除C和C++实现

2024年1月9日 557次阅读 来源: 二叉查找树

程序是建立一颗二叉排序树，查找节点找到了返回其父节点，失败的时候返回NULL，删除节点分为四种情况：1、左子树和右子树都为空；2、左子树为空，右子树不为空；3、左子树不为空，右子树为空；4、左子树和右子树都不为空。

C语言版本（利用结构体实现）：

[cpp] 
view plain
copy
print
?

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3.    
  4. typedef int DataType;  
  5.    
  6. typedef struct BTree{  
  7.     DataType data;  
  8.     struct BTree *Tleft;  
  9.     struct BTree *Tright;     
  10. }*BTree;  
  11.   
  12. BTree CreateTree(); //建树   
  13. BTree insert(BTree root, DataType data);//插入节点   
  14. void InBTree(BTree root); //中序遍历   
  15. void PreBTree(BTree root); //先序遍历   
  16. void PostBTree(BTree root);//后序遍历   
  17. BTree findPostion(BTree root, int deleteNode, int *flags);//寻找合适的插入点   
  18. BTree delNode(BTree root, BTree parent, int flags); //删除树节点   
  19.   
  20. int main(){  
  21.     BTree root = NULL;  
  22.     int flags = 0;  
  23.     int deleteNode = 0;   
  24.     BTree parent = NULL;//所删除节点的父节点   
  25.     char choiceAgain = ‘Y’;   
  26.     root = CreateTree();  
  27.     printf(“\n中序遍历: “);  
  28.     InBTree(root);   
  29.     printf(“\n前序遍历: “);   
  30.     PreBTree(root);  
  31.     printf(“\n后序遍历: “);  
  32.     PostBTree(root);  
  33.     printf(“\n”);   
  34.       
  35.     do{   
  36.         printf(“需要删掉的节点: “);  
  37.         scanf(“%d”, &deleteNode);   
  38.         parent = findPostion(root, deleteNode, &flags);  
  39.         root = delNode(root, parent, flags);   
  40.         printf(“删除后的结果: “);   
  41.         printf(“\n中序遍历: “);  
  42.         InBTree(root);   
  43.         printf(“\n前序遍历: “);  
  44.         PreBTree(root);   
  45.         printf(“\n后序遍历: “);  
  46.         PostBTree(root);  
  47.         choiceAgain = ‘N’;  
  48.         printf(“\nDelete Again(Y) or N?: “);  
  49.         getchar();   
  50.         scanf(“%c”, &choiceAgain);   
  51.     }while(choiceAgain == ‘Y’ || choiceAgain == ‘y’);   
  52.       
  53.     printf(“\nDone!\n”);   
  54.     return 0;   
  55. }  
  56.   
  57. BTree CreateTree(){  
  58.     BTree root = NULL;  
  59.     DataType temp = 0;  
  60.     printf(“请输入节点,以0结尾:\n”);   
  61.     scanf(“%d”, &temp);   
  62.     while(temp != 0){  
  63.         root = insert(root, temp);    
  64.         scanf(“%d”, &temp);    
  65.     }  
  66.       
  67.     return root;   
  68. }   
  69.   
  70. BTree insert(BTree root, DataType data){  
  71.     BTree ptr = root;  
  72.     BTree tempNode;   
  73.     BTree newNode = (BTree)malloc(sizeof(struct BTree));   
  74.     newNode->data = data ;  
  75.     newNode->Tleft = NULL;  
  76.     newNode->Tright = NULL;  
  77.       
  78.     if(ptr == NULL){  
  79.         return newNode;   
  80.     }else{  
  81.         while(ptr != NULL){  
  82.             tempNode = ptr;   
  83.             if(ptr->data >= data){  
  84.                 ptr = ptr->Tleft;   
  85.             }else{  
  86.                 ptr = ptr->Tright;   
  87.             }   
  88.         }   
  89.           
  90.         if(tempNode->data >= data){  
  91.             tempNode->Tleft =  newNode;   
  92.         }else{  
  93.             tempNode->Tright =  newNode;   
  94.         }   
  95.     }  
  96.     return root;   
  97. }  
  98.   
  99. BTree findPostion(BTree root, int deleteNode, int *flags){  
  100.     BTree parentNode = root;  
  101.     BTree temp = root;   
  102.     *flags = 0;  
  103.       
  104.     while(temp != NULL){  
  105.         if(temp->data == deleteNode){  
  106.             return parentNode;         
  107.         }else{  
  108.             parentNode = temp;   
  109.             if(temp->data > deleteNode){  
  110.                 temp = temp->Tleft;  
  111.                 *flags = -1;   
  112.             }else{  
  113.                 temp = temp->Tright;   
  114.                 *flags = 1;  
  115.             }  
  116.         }      
  117.     }  
  118.       
  119.     return NULL;   
  120. }   
  121.   
  122. BTree delNode(BTree root, BTree parent, int flags){  
  123.     BTree deleteNode = NULL;  
  124.        
  125.     if(parent == NULL){  
  126.         printf(“未找到删除的节点!\n”);  
  127.         return root;   
  128.     }  
  129.       
  130.     switch(flags){  
  131.     case -1:  
  132.         deleteNode = parent->Tleft;  
  133.         break;  
  134.     case 0:  
  135.         deleteNode = parent;  
  136.         break;  
  137.     case 1:   
  138.         deleteNode = parent->Tright;  
  139.         break;  
  140.     default:  
  141.         printf(“ERROR!\n”);   
  142.         exit(1);   
  143.     }  
  144.       
  145.     if(deleteNode->Tleft == NULL && deleteNode->Tright == NULL){  
  146.         if(parent->Tleft == deleteNode){  
  147.             parent->Tleft = NULL;   
  148.         }else if(parent->Tright == deleteNode){  
  149.             parent->Tright = NULL;   
  150.         }else{  
  151.             parent = NULL;   
  152.         }   
  153.         free(deleteNode);  
  154.     }else if(deleteNode->Tleft == NULL && deleteNode->Tright != NULL){  
  155.         if(deleteNode->data == root->data){  
  156.             root = deleteNode->Tright;   
  157.         }else{  
  158.             if(parent->Tleft->data == deleteNode->data){  
  159.                 parent->Tleft = deleteNode->Tright;  
  160.             }else{  
  161.                 parent->Tright = deleteNode->Tright;  
  162.             }  
  163.         }   
  164.         free(deleteNode);  
  165.     }else if(deleteNode->Tleft != NULL && deleteNode->Tright == NULL){  
  166.         if(deleteNode->data == root->data){  
  167.             root = deleteNode->Tleft;  
  168.         }else{  
  169.             if(parent->Tleft->data == deleteNode->data){  
  170.                 parent->Tleft = deleteNode->Tleft;  
  171.             }else{  
  172.                 parent->Tright = deleteNode->Tleft;  
  173.             }  
  174.         }  
  175.         free(deleteNode);  
  176.     }else{  
  177.         BTree temp = deleteNode->Tleft;  
  178.         BTree tempParent = deleteNode;  
  179.         while(temp->Tright != NULL){  
  180.             tempParent = temp;  
  181.             temp = temp->Tright;  
  182.         }  
  183.           
  184.         deleteNode->data = temp->data;  
  185.         if(tempParent->Tleft == temp){  
  186.             tempParent->Tleft = temp->Tleft;    
  187.         }else{  
  188.             tempParent->Tright = temp->Tleft;  
  189.         }  
  190.           
  191.         printf(“temp = %d\n”, temp->data);  
  192.         free(temp);  
  193.     }   
  194.       
  195.     return root;      
  196. }   
  197.   
  198. void InBTree(BTree root){  
  199.     if(root != NULL){  
  200.         InBTree(root->Tleft);   
  201.         printf(“%d “, root->data);   
  202.         InBTree(root->Tright);  
  203.     }  
  204. }  
  205.   
  206. void PreBTree(BTree root){  
  207.     if(root != NULL){  
  208.         printf(“%d “, root->data);   
  209.         PreBTree(root->Tleft);   
  210.         PreBTree(root->Tright);  
  211.     }  
  212. }   
  213.   
  214. void PostBTree(BTree root){  
  215.     if(root != NULL){  
  216.         PostBTree(root->Tleft);   
  217.         PostBTree(root->Tright);  
  218.         printf(“%d “, root->data);  
  219.     }  
  220. }   

C++版本(利用类实现)

[cpp] 
view plain
copy
print
?

  1. #include <iostream.h>  
  2. #include <cstring>  
  3.   
  4. typedef int KeyType;  
  5. #define NUM 11  
  6. class BinStree;  
  7. class BinSTreeNode  
  8. {  
  9. public:  
  10.     KeyType key;  
  11.     BinSTreeNode *lchild;  
  12.     BinSTreeNode *rchild;  
  13.     BinSTreeNode()  
  14.     {  
  15.         lchild = NULL;  
  16.         rchild = NULL;  
  17.     }  
  18. };  
  19.   
  20. class BinSTree  
  21. {  
  22. public:  
  23.     BinSTreeNode *root;  
  24.     BinSTree()  
  25.     {  
  26.         root = NULL;  
  27.     }  
  28.     ~BinSTree()  
  29.     {  
  30.         //delete root;  
  31.     }  
  32.     BinSTreeNode *BSTreeSearch( BinSTreeNode *bt, KeyType k, BinSTreeNode *&p );  
  33.     void BSTreeInsert( BinSTreeNode *&bt, KeyType k );  
  34.     int BSTreeDelete( BinSTreeNode *&bt, KeyType k );  
  35.     void BSTreePreOrder(BinSTreeNode *bt);  
  36.     bool IsEmpty()  
  37.     {  
  38.         return root == NULL;  
  39.     }  
  40. };  
  41.   
  42. /** 
  43.   *  二叉树排序查找算法 
  44.   *  在根指针为bt的二叉排序树中查找元素k的节点，若查找成功，则返回指向该节点的指针 
  45.   *  参数p指向查找到的结点，否则返回空指针，参数p指向k应插入的父结点 
  46.   */  
  47. BinSTreeNode* BinSTree::BSTreeSearch( BinSTreeNode *bt, KeyType k, BinSTreeNode *&p )  
  48. {  
  49.     BinSTreeNode *q = NULL;  
  50.     q = bt;  
  51.     while(q)  
  52.     {  
  53.         p = q;  
  54.         if( q->key == k )  
  55.         {  
  56.             return(p);  
  57.         }  
  58.         if( q->key > k )  
  59.             q = q->lchild;  
  60.         else  
  61.             q = q->rchild;  
  62.     }  
  63.     return NULL;  
  64. }  
  65.   
  66. /** 
  67.   *  二叉排序树的插入节点算法 
  68.   *  bt指向二叉排序树的根结点，插入元素k的结点 
  69.   */  
  70. void BinSTree::BSTreeInsert( BinSTreeNode *&bt, KeyType k )  
  71. {  
  72.     BinSTreeNode *p = NULL, *q;  
  73.     q = bt;  
  74.     if( BSTreeSearch( q, k, p ) == NULL )  
  75.     {  
  76.         BinSTreeNode *r = new BinSTreeNode;  
  77.         r->key = k;  
  78.         r->lchild = r->rchild = NULL;  
  79.         if( q == NULL )  
  80.         {  
  81.             bt = r;         //被插入节点做为树的根节点  
  82.         }  
  83.         if( p && k < p->key )  
  84.             p->lchild = r;  
  85.         else if( p )  
  86.             p->rchild = r;  
  87.     }  
  88. }  
  89. /** 
  90.  * 中序遍历  
  91.  */   
  92. void BinSTree::BSTreePreOrder(BinSTreeNode *bt)  
  93. {  
  94.     if(bt != NULL)  
  95.     {  
  96.         cout << bt->key << ” “;  
  97.         BSTreePreOrder(bt->lchild);  
  98.         BSTreePreOrder(bt->rchild);  
  99.     }  
  100. }  
  101. /** 
  102.   * 二叉排序树的删除结点算法 
  103.   * 在二叉排序树中删除元素为k的结点，*bt指向二叉排序树的根节点 
  104.   * 删除成功返回1，不成功返回0. 
  105.   */  
  106. int BinSTree::BSTreeDelete( BinSTreeNode *&bt, KeyType k )  
  107. {  
  108.     BinSTreeNode *f, *p, *q, *s;  
  109.     p = bt;  
  110.     f = NULL;  
  111.     //查找关键字为k的结点，同时将此结点的双亲找出来  
  112.     while( p && p->key != k )  
  113.     {  
  114.         f = p;  
  115.         if( p->key > k )  
  116.             p = p->lchild;  
  117.         else  
  118.             p = p->rchild;  
  119.     }  
  120.     if( p == NULL )   //找不到待删除的结点时返回  
  121.         return 0;  
  122.     if( p->lchild == NULL )  //待删除结点的左子树为空  
  123.     {  
  124.         if( f == NULL )  //待删除结点为根节点  
  125.             bt = p->rchild;  
  126.         else if( f->lchild == p )  //待删结点是其双亲结点的左节点  
  127.             f->lchild = p->rchild;  
  128.         else  
  129.             f->rchild = p->rchild;  //待删结点是其双亲结点的右节点  
  130.         delete p;  
  131.     }  
  132.     else                    //待删除结点有左子树  
  133.     {  
  134.         q = p;  
  135.         s = p->lchild;  
  136.         while( s->rchild )  //在待删除结点的左子树中查找最右下结点  
  137.         {  
  138.             q = s;  
  139.             s = s->rchild;  
  140.         }  
  141.         if( q == p )  
  142.             q->lchild = s->lchild;  
  143.         else  
  144.             q->rchild = s->lchild;  
  145.   
  146.         p->key = s->key;  
  147.         delete s;  
  148.     }  
  149.     return 1;  
  150. }  
  151. int main( void )  
  152. {  
  153.     int a[NUM] = { 34, 18, 76, 13, 52, 82, 16, 67, 58, 73, 72 };  
  154.     int i;  
  155.     BinSTree bst;  
  156.     BinSTreeNode *pBt = NULL, *p = NULL, *pT = NULL;  
  157.   
  158.     for( i = 0; i < NUM; i++ )  
  159.     {  
  160.         bst.BSTreeInsert( pBt, a[i] ); //创建二叉排序树  
  161.     }  
  162.     pT = bst.BSTreeSearch( pBt, 52, p ); //搜索排序二叉树  
  163.     bst.BSTreePreOrder(pBt);  
  164.     cout << endl;  
  165.     bst.BSTreeDelete( pBt, 13 );   //删除无左孩子的情况  
  166.     bst.BSTreePreOrder(pBt);  
  167.     cout << endl;  
  168.     bst.BSTreeDelete( pBt, 76 );   //删除有左孩子的情况  
  169.     bst.BSTreePreOrder(pBt);  
  170.     cout << endl;  
  171.     return 0;  

原文地址：点击打开链接

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