2. 程式人生 > >BST：二叉排序樹演算法

BST：二叉排序樹演算法

阿新 • • 發佈：2019-02-14 
      建立二叉排序樹，實現樹的插入、刪除，前、中、後序遍歷（遞迴方式）等操作。

  1. #include <iostream>
  2. #include "Binary_Tree.h"
  3. usingnamespace std;  
  4. int main()  
  5. {  
  6.     int N = 0;  
  7.     int *data;  
  8.     cout << "N = ";  
  9.     cin >> N;  
  10.     data = (int *)malloc(N * sizeof(int));  
  11.     cout << "資料:";  
  12.     for (int i = 0; i < N; ++i)  
  13.     {  
  14.         cin >> data[i];  
  15.     }  
  16.     //30 12 54 8 24 35 70 19 28 48
  17.     //30 12 54 24 35 70 19 28 48 37 36 38
  18.     BT BTree;  
  19.     BTree.Create_Binary_Sort_Tree(data, N);  
  20.     while(1)  
  21.     {  
  22.         cout << "1.遍歷\t2.插入\t3.刪除\t4.退出"<<endl;  
  23.         cout <<"選擇:";  
  24.         int choice;  
  25.         cin >> choice;  
  26.         switch(choice)  
  27.         {  
  28.             case 1:  
  29.                 cout << "前序:";  
  30.                 BTree.Pre_Oder_Traverse(BTree.root);  
  31.                 cout << endl;  
  32.                 cout << "中序:";  
  33.                 BTree.In_Oder_Traverse(BTree.root);  
  34.                 cout << endl;  
  35.                 cout << "後序:";  
  36.                 BTree.Post_Oder_Traverse(BTree.root);  
  37.                 cout << endl;  
  38.                 break;  
  39.             case 2:  
  40.                 cout << "插入:";  
  41.                 int value;  
  42.                 cin >> value;  
  43.                 BTree.Insert_Elem(value);  
  44.                 break;  
  45.             case 3:  
  46.                 cout << "刪除:";  
  47.                 cin >> value;  
  48.                 BTree.Delete_Elem(value);  
  49.                 break;  
  50.             case 4:  
  51.                 return 0;  
  52.                 break;  
  53.             default:  
  54.                 break;  
  55.         }  
  56.     }  
  57.     return 0;  
  58. }  
  1. /*****************************************    
  2. Copyright (c) 2015 Jingshuang Hu    
  3. @filename:Binary_Tree.h    
  4. @datetime:2015.11.03    
  5. @author:HJS    
  6. @e-mail:[email protected]    
  7. @blog:http://blog.csdn.net/hujingshuang    
  8. *****************************************/
  9. #ifndef _BINARY_TREE_H_
  10. #define _BINARY_TREE_H_
  11. #include <iostream>
  12. usingnamespace std;  
  13. struct Tree  
  14. {  
  15.     int elem;  
  16.     Tree *left;  
  17.     Tree *right;  
  18. };  
  19. class BT  
  20. {  
  21. public:  
  22.     BT();                                           //建構函式
  23.     void Create_Binary_Sort_Tree(int *, int);       //建立二叉樹
  24.     void Pre_Oder_Traverse(Tree *);                 //前序
  25.     void In_Oder_Traverse(Tree *);                  //中序
  26.     void Post_Oder_Traverse(Tree *);                //後序
  27.     void Insert_Elem(int);                          //插入
  28.     void Delete_Elem(int);                          //刪除
  29. //  void Show_Tree(void);                           //顯示二叉樹
  30. //  virtual void Level_Oder_Traverse(Tree *) = 0;   //純虛擬函式
  31. //private:
  32.     Tree *root;  
  33. };  
  34. #endif
  1. /*****************************************    
  2. Copyright (c) 2015 Jingshuang Hu    
  3. @filename:Binary_Tree.cpp    
  4. @datetime:2015.11.03    
  5. @author:HJS    
  6. @e-mail:[email protected]    
  7. @blog:http://blog.csdn.net/hujingshuang    
  8. *****************************************/
  9. #include "Binary_Tree.h"
  10. //初始化二叉樹
  11. BT::BT()  
  12. {  
  13.     root = NULL;  
  14. }  
  15. //建立二叉樹
  16. void BT::Create_Binary_Sort_Tree(int *data, int N)  
  17. {  
  18.     Tree *nowfreenode = new Tree;                   //生成新的節點
  19.     Tree *prefreenode = new Tree;  
  20.     root = new Tree;  
  21.     root->elem = data[0];                            //父節點元素
  22.     root->left = root->right = NULL;              //左右孩子為空
  23. //30 12 54 8 24 35 70 19 28 48
  24.     for (int i = 1; i < N; ++i)  
  25.     {  
  26.         nowfreenode = root;  
  27.         Tree *newnode = new Tree;                   //生成新的節點
  28.         newnode->elem = data[i];  
  29.         newnode->left = newnode->right = NULL;  
  30.         while(nowfreenode != NULL)                  //空
  31.         {  
  32.             prefreenode = nowfreenode;              //用於記錄前一個節點
  33.             if (newnode->elem < nowfreenode->elem) //掛在左邊
  34.             {  
  35.                 nowfreenode = nowfreenode->left;  
  36.             }  
  37.             else
  38.             {  
  39.                 nowfreenode = nowfreenode->right;    //掛在右邊
  40.             }   
  41.         }  
  42.         if (newnode->elem < prefreenode->elem)  
  43.         {  
  44.             prefreenode->left = newnode;  
  45.         }  
  46.         else
  47.         {  
  48.             prefreenode->right = newnode;  
  49.         }  
  50.     }  
  51.     delete nowfreenode;  
  52. //  delete prefreenode;
  53. }  
  54. //前序
  55. void BT::Pre_Oder_Traverse(Tree *T)  
  56. {  
  57.     if (T != NULL)  
  58.     {  
  59.         cout << T->elem << " ";  
  60.         Pre_Oder_Traverse(T->left);  
  61.         Pre_Oder_Traverse(T->right);  
  62.     }  
  63. }  
  64. //中序
  65. void BT::In_Oder_Traverse(Tree *T)  
  66. {  
  67.     if (T != NULL)  
  68.     {  
  69.         In_Oder_Traverse(T->left);  
  70.         cout << T->elem << " ";   
  71.         In_Oder_Traverse(T->right);  
  72.     }  
  73. }  
  74. //後序
  75. void BT::Post_Oder_Traverse(Tree *T)  
  76. {  
  77.     if (T != NULL)  
  78.     {  
  79.         Post_Oder_Traverse(T->left);  
  80.         Post_Oder_Traverse(T->right);  
  81.         cout << T->elem << " ";  
  82.     }  
  83. }  
  84. //插入
  85. void BT::Insert_Elem(int data)  
  86. {  
  87.     Tree *nowfreenode = new Tree;  
  88.     Tree *prefreenode = new Tree;  
  89.     nowfreenode = root;  
  90.     Tree *newnode = new Tree;                   //生成新的節點
  91.     newnode->elem = data;  
  92.     newnode->left = newnode->right = NULL;  
  93.     while(nowfreenode != NULL)                  //空
  94.     {  
  95.         prefreenode = nowfreenode;              //用於記錄前一個節點
  96.         if (newnode->elem < nowfreenode->elem) //掛在左邊
  97.         {  
  98.             nowfreenode = nowfreenode->left;  
  99.         }  
  100.         else
  101.         {  
  102.             nowfreenode = nowfreenode->right;    //掛在右邊
  103.         }   
  104.     }  
  105.     if (newnode->elem < prefreenode->elem)  
  106.     {  
  107.         prefreenode->left = newnode;  
  108.     }  
  109.     else
  110.     {  
  111.         prefreenode->right = newnode;  
  112.     }  
  113. }  
  114. //刪除
  115. void BT::Delete_Elem(int data)  
  116. {  
  117.     Tree *prefreenode = new Tree;  
  118.     Tree *nowfreenode = new Tree;  
  119.     nowfreenode = root;  
  120.     Tree *newnode = new Tree;  
  121.     newnode->elem = data;  
  122.     newnode->left = newnode->right = NULL;  
  123.     prefreenode = nowfreenode;  
  124.     //找到元素所在節點nowfreenode
  125.     while((nowfreenode != NULL) && (newnode->elem != nowfreenode->elem))  
  126.     {  
  127.         prefreenode = nowfreenode;  
  128.         if (newnode->elem < nowfreenode->elem)     //往左走
  129.         {  
  130.             nowfreenode = nowfreenode->left;  
  131.         }  
  132.         elseif (newnode->elem > nowfreenode->elem)    //往右走
  133.         {  
  134.             nowfreenode = nowfreenode->right;  
  135.         }  
  136.     }  
  137. //
  138.     if ((nowfreenode->left != NULL) && (nowfreenode->right == NULL))//只有左子樹，用左子樹代替節點
  139.     {     
  140.         if ((prefreenode->left != NULL) && (prefreenode->left->elem == nowfreenode->elem))  
  141.         {  
  142.             prefreenode->left = nowfreenode->left;  
  143.         }  
  144.         else
  145.         {  
  146.             if (prefreenode == nowfreenode)  
  147.             {  
  148.                 root = nowfreenode->left;  
  149.             }  
  150.             else
  151.             {  
  152.                 prefreenode->right = nowfreenode->left;  
  153.             }  
  154.         }  
  155.     }  
  156.     elseif ((nowfreenode->left == NULL) && (nowfreenode->right != NULL))//只有右子樹，用右子樹代替節點
  157.     {  
  158.         if ((prefreenode->left != NULL) && (prefreenode->left->elem == nowfreenode->elem))  
  159.         {  
  160.             prefreenode->left = nowfreenode->right;  
  161.         }  
  162.         else
  163.         {  
  164.             if (prefreenode == nowfreenode)  
  165.             {  
  166.                 root = nowfreenode->right;  
  167.             }  
  168.             else
  169.             {  
  170.                 prefreenode->right = nowfreenode->right;  
  171.             }  
  172.         }  
  173.     }  
  174.     elseif ((nowfreenode->left == NULL) && (nowfreenode->right == NULL))//是葉子節點，直接刪除
  175.     {  
  176.         if ((prefreenode->left != NULL) && (prefreenode->left->elem == nowfreenode->elem))  
  177.             prefreenode->left = NULL;  
  178.         else
  179.             prefreenode->right = NULL;  
  180.     }  
  181.     else//左右子樹都存在，用左子樹最右節點代替節點
  182.     {  
  183.         prefreenode = nowfreenode;  
  184.         nowfreenode = nowfreenode->left;  
  185.         Tree *pfreenode = prefreenode;  
  186.         while(nowfreenode->right != NULL)  
  187.         {  
  188.             pfreenode = nowfreenode;  
  189.             nowfreenode = nowfreenode->right;  
  190.         }  
  191.         prefreenode->elem = nowfreenode->elem;  
  192.         pfreenode->right = nowfreenode->left;  
  193.         delete prefreenode;  
  194.     }  
  195. //  delete nowfreenode;
  196. } 
本文來自：http://blog.csdn.net/hujingshuang/article/details/49679991

相關推薦

【資料結構】BST：二叉排序樹演算法

建立二叉排序樹，實現樹的插入、刪除，前、中、後序遍歷（遞迴方式）等操作。 /***************************************** Copyright (c) 2015 Jingshuang Hu @filename:dem

BST：二叉排序樹演算法

建立二叉排序樹，實現樹的插入、刪除，前、中、後序遍歷（遞迴方式）等操作。 #include <iostream>#include "Binary_Tree.h"usingnamespace std;  int main()  {      int 

Android版資料結構與演算法(八)：二叉排序樹

本文目錄 前兩篇文章我們學習了一些樹的基本概念以及常用操作，本篇我們瞭解一下二叉樹的一種特殊形式：二叉排序樹（Binary Sort Tree），又稱二叉查詢樹（Binary Search Tree），亦稱二叉搜尋樹。 一、二叉排序樹定義 二叉排序樹或者是一顆空樹，或者是具有下列性質的二叉樹：

資料結構與演算法：二叉排序樹

二叉排序樹 二叉排序樹（Binary Sort Tree），又稱二叉查詢樹（Binary Search Tree），亦稱二叉搜尋樹。是資料結構中的一類。在一般情況下，查詢效率比連結串列結構要高。 二叉排序樹的定義： 當左子樹不為空時，左子樹上的所有節點值都小於左子樹的根節點值 當右子樹不為空時，右子樹

BST（二叉排序樹）的插入與刪除

最小值 temp def oot gpo 一個 記錄 通過 如果 值得一說的是刪除操作，刪除操作我們分為三種情況： 1.要刪的節點有兩個孩子： 　　找到左子樹中的最大值或者右子樹中的最小值所對應的節點，記為node，並把node的值賦給要刪除的節點del,然後刪除node

C++ 判斷一顆樹騰訊分是分網站開發否是BST（二叉排序樹)

sizeof 存儲 tno ret turn bre 打印 二叉 添加 因為騰訊分分網站開發 haozbbs.com Q1446595067二叉排序樹的中序遍歷結果是遞增的，所以可以通過中序遍歷存儲結果，再判斷是否為遞增的數組。1) 對樹進行中序遍歷，將結果保存在b[]

資料結構作業：二叉排序樹及其相關操作

寫了一個簡單的。 因為自己對泛型瞭解的還是不夠到位，所以只能寫個demo版的。 這課樹沒辦法維持平衡，希望以後學一下紅黑樹，替罪羊樹etc.   /* * 簡單的二叉查詢樹 * 沒有自帶旋轉平衡 * 寫完這個我學一下 * avl樹還有紅黑樹 */ public c

Android版數據結構與算法(八)：二叉排序樹

delet 概念 最好 指定 性能 and 並且 二叉樹 排列 本文目錄 前兩篇文章我們學習了一些樹的基本概念以及常用操作，本篇我們了解一下二叉樹的一種特殊形式：二叉排序樹（Binary Sort Tree），又稱二叉查找樹（Binary Search Tree），亦稱二

資料結構實驗之查詢一：二叉排序樹 （SDUT 3373）

二叉排序樹（Binary Sort Tree），又稱二叉查詢樹（Binary Search Tree），也稱二叉搜尋樹。 #include <stdio.h> #include <string.h> #include <stdlib.h> struct nod

Java資料結構：二叉排序樹的刪除操作

嚶嚶嚶，今天補回昨天沒有寫的部落格。 二叉排序樹的刪除操作比較簡單，但是思想很全面，因此本人就寫一篇部落格紀念一下。 思想：四種類型也可以是三種 1，刪除結點p的度為2，即有左右子樹。 此時有兩種方法，第一種將結點的左子樹在中根遍歷下的最後一個結點放到p的位置。第二種是將p結點

SDUT3374資料結構實驗之查詢一：二叉排序樹

判斷是否為同一棵二叉排序樹 解決這個問題需要兩步： 1.建立二叉排序樹 2.判斷兩棵樹是否相同 詳情看程式碼和註釋，懶人程式碼 #include <iostream> #include <cstring> using namespace std; type

九度筆記之 1467：二叉排序樹

題目1467：二叉排序樹 時間限制：1 秒 記憶體限制：128 兆 特殊判題：否 提交：1292 解決：518 題目描述：         二叉排序樹，也稱為二叉查詢樹。可以是一顆空樹，也可以是一顆具有如下特性的非空二叉樹：         1

判斷一棵樹是否是二叉排序樹演算法的巧妙之處

運用全域性變數pre和中序遍歷的思想，儲存上一個結點的指標，然後將當前結點和上一個結點進行比較，從而作出判斷。 typedef struct { KeyType key; ... ..

重溫資料結構：二叉排序樹的查詢、插入、刪除

讀完本文你將瞭解到： 我們知道，二分查詢可以縮短查詢的時間，但是有個要求就是 查詢的資料必須是有序的。每次查詢、操作時都要維護一個有序的資料集，於是有了二叉排序樹這個概念。 上篇文章 我們介紹了 二叉樹 的概念，二叉樹有左右子樹之分，想必在區分左右子樹

構造二叉排序樹（BST）+二叉排序樹的刪除

主要是刪除操作 二叉排序樹的刪除 1. 刪除葉結點，直接刪除 2. 刪除結點p只有左子樹或右子樹，讓其子樹替代該結點p即可 3. 刪除結點p既有左子樹又有右子樹，以該結點p為根，查詢中序遍歷下第一個結點t，使這個結點t替換p結點（val覆蓋即可），再遞迴一次刪除這個結點t即

九度OJ題目1201：二叉排序樹

紀念一下終於在二叉樹上的程式碼準確率，但還是在給root分配空間的時候忘記要寫了  悲劇 還沒看到提示要考慮忽略重複元素，這個好解決 題目描述：     輸入一系列整數，建立二叉排序數，並進行前

九度 題目1467：二叉排序樹

程式碼設計： #include <iostream> #include <algorithm> #include <stdio.h> using namespace

題目1467：二叉排序樹 九度OJ

題目1467：二叉排序樹 時間限制：1 秒 記憶體限制：128 兆 特殊判題：否 提交：4745 解決：1953 題目描述：         二叉排序樹，也稱為二叉查詢樹。可以

C++ 判斷一顆樹是否是BST（二叉排序樹)

方法一:使用中序遍歷因為二叉排序樹的中序遍歷結果是遞增的，所以可以通過中序遍歷儲存結果，再判斷是否為遞增的陣列。1) 對樹進行中序遍歷，將結果儲存在b[]陣列中。2) 檢測b[]陣列中元素是否為升序排列。如果是，則這棵樹為BST.時間複雜度: O(n)程式碼如下:#inclu

演算法題（三十一）：二叉搜尋樹（BST）的後序遍歷序列

題目描述 輸入一個整數陣列，判斷該陣列是不是某二叉搜尋樹的後序遍歷的結果。如果是則輸出Yes,否則輸出No。假設輸入的陣列的任意兩個數字都互不相同。 分析 後序遍歷序列中，最右邊數字也就是根結點，會把數集分為左右兩部分，左邊數集都小於root，右邊數集都大於root。左