二叉树c++实现
！！版权声明：本文为博主原创文章，版权归原文作者和博客园共有，谢绝任何形式的 转载！！
作者：mohist
--- 欢迎指正---
二叉树特点：
要么为空树；要么，当前结点的左孩子比当前结点值小，当前结点的右孩子比当前结点的值大。
1、插入：
1.1 插入结点的值比当前结点的值小，继续找当前结点的左子树，
1.2 插入结点的值比当前结点的值大，继续找当前结点的右子树，
1.3 找到合适的位置了，插入树。
2、删除：
2.1 删除结点是叶子结点，直接将其删除即可
2.2 删除结点只有左孩子或者只有右孩子，将其孩子结点删除，并将指向孩子结点的分支设置为空，c++是设置为NULL。不过更好的做法是，将孩子结点的值替换到当前结点，再删除孩子结点即可。
2.3 删除的结点同时含有左孩子与右孩子，需要找到删除结点的后继结点，将后继结点作为当前结点。
完整源码：
#include <iostream> using namespace std; struct node { // 数据域 int data; // 左节点 node *lc; // 右结点 node *rc; // 构造函数 node() : data(0) , lc(NULL) , rc(NULL) { } }; // bst class bstree { public: enum { hmax_size_32767 = 32767, hmin_size_0 = 0, }; public: // 构造函数 bstree() : root(NULL) , size(0) { } // 析构函数 virtual ~bstree(){} int get_size() { return size; } // 插入结点 void insert_node(int data) { int cur_size = get_size(); if (hmax_size_32767 == cur_size) { cout << "insert node error, the size of the tree is max" << endl; return ; } root = insert(root, data); } // 先序遍历（前序遍历） void pre_order() { pre_order_traverse(root); } // 中序遍历 void in_order() { in_order_traverse(root); } // 后序遍历 void post_order() { post_order_traverse(root); } /* 查找某个结点 int key - 查找结果 返回值： NULL : 可能为root为空 或者 没有找到 != NULL, 找到结点 */ node* query(int key) { if (NULL == root) { cout << "query error, root = null" << endl; return NULL; } return query_node(root, key); } // 删除树 void remove_all() { if (NULL == root) { cout << "remove all failed, root = null" << endl; return; } remove_all(root); int cur_size = get_size(); if (0 == cur_size) root = NULL; } // 删除某个结点 void remove_node(int del_data) { if (NULL == root) { cout << "remove node error, root = null" << endl; return; } node *parent_node = NULL; node *del_node = root; // 找到删除结点的父节点与删除结点 while (del_node) { if (del_data == del_node->data) break; else if (del_data > del_node->data) { parent_node = del_node; del_node = del_node->rc; } else if (del_data < del_node->data) { parent_node = del_node; del_node = del_node->lc; } } // 若没有找到要删除的结点 if (NULL == del_node) { cout << "remove node error, " << del_data << " was not find" << endl; return; } // 1、若删除的结点没有左子树和右子树 if ( (NULL == del_node->lc) && (NULL == del_node->rc) ) { // 为什么要先判断根结点，因为根结点的父节点找不到，结果为NULL， // 1.1 可能只有一个根结点， 将root释放值为空 if (del_node == root) { root = NULL; delete del_node; del_node = NULL; dec_size(); return; } // 1.2 非根结点，那就是叶子结点了， 将父节点指向删除结点的分支指向NULL if (del_node == parent_node->lc) parent_node->lc = NULL; else if (del_node == parent_node->rc) parent_node->rc = NULL; // 释放结点 delete del_node; del_node = NULL; dec_size(); } // 2、若删除结点只有左孩子，没有右孩子 else if ( (NULL != del_node->lc) && (NULL == del_node->rc) ) { // 2.1 删除结点为根结点，则将删除结点的左孩子替代当前删除结点 if (del_node == root) { root = root->lc; } // 2.2 其他结点，将删除结点的左孩子作为父节点的左孩子 else { if (parent_node->lc == del_node) parent_node->lc = del_node->lc; else if (parent_node->rc == del_node) parent_node->rc = del_node->lc; } delete del_node; del_node = NULL; dec_size(); } // 3、若删除结点只有右孩子 else if ( (NULL == del_node->lc) && (NULL != del_node->rc) ) { // 3.1 若为根结点 if (root == del_node) { root = root->rc; } else { if (del_node == parent_node->lc) parent_node->lc = del_node->rc; else if (del_node == parent_node->rc) parent_node->rc = del_node->rc; } delete del_node; del_node = NULL; dec_size(); } // 4、若删除结点既有左孩子，又有右孩子,需要找到删除结点的后继结点作为根结点 else if ( (NULL != del_node->lc) && (NULL != del_node->rc) ) { node *successor_node = del_node->rc; parent_node = del_node; while (successor_node->lc) { parent_node = successor_node; successor_node = successor_node->lc; } // 交换后继结点与当前删除结点的数据域 del_node->data = successor_node->data; // 将指向后继结点的父节点的孩子设置后继结点的右子树 if (successor_node == parent_node->lc) parent_node->lc = successor_node->rc; else if (successor_node == parent_node->rc) parent_node->rc = successor_node->rc; // 删除后继结点 del_node = successor_node; delete del_node; del_node = NULL; dec_size(); } } // 返回以proot为根结点的最小结点 node *get_min_node(node *proot) { if (NULL == proot->lc) return proot; return get_min_node(proot->lc); } // 返回以proo为根节点的最大结点 node *get_max_node(node *proot) { if (NULL == proot->rc) return proot; return get_max_node(proot->rc); } // 返回根节点 node *get_root_node() { return root; } // 返回proot结点的父节点 node *get_parent_node(int key) { // 当前结点 node *cur_node = NULL; // 父节点 node *parent_node = NULL; cur_node = root; // 标记是否找到 bool is_find = false; while (cur_node) { if (key == cur_node->data) { is_find = true; break; } // 因为比当前结点的值还要小，所以需要查找当前结点的左子树 else if (key < cur_node->data) { parent_node = cur_node; cur_node = cur_node->lc; } // 同上， 查找当前结点的右子树 else if (key > cur_node->data) { parent_node = cur_node; cur_node = cur_node->rc; } } return (true == is_find)? parent_node : NULL; } private: //查找某个值 node *query_node(node *proot, int key) { if (NULL == proot) { return proot; } if (proot->data == key) return proot; else if (proot->data > key) { return query_node(proot->lc, key); } else if (proot->data < key) { return query_node(proot->rc, key); } return NULL; } // 后序遍历删除所有结点 void remove_all(node *proot) { if (NULL != proot) { remove_all(proot->lc); remove_all(proot->rc); delete proot; dec_size(); } } // 先序遍历 void pre_order_traverse(node *proot) { if (NULL != proot) { cout << proot->data << ", "; pre_order_traverse(proot->lc); pre_order_traverse(proot->rc); } } // 中序遍历 void in_order_traverse(node *proot) { if (NULL != proot) { in_order_traverse(proot->lc); cout << proot->data << ", "; in_order_traverse(proot->rc); } } // 后续遍历 void post_order_traverse(node *proot) { if (NULL != proot) { post_order_traverse(proot->lc); post_order_traverse(proot->rc); cout << proot->data << ", "; } } // 插入结点 node *insert(node *proot, int data) { // 结点不存在， 则创建 if (NULL == proot) { node *new_node = new(std::nothrow) node; if (NULL != new_node) { new_node->data = data; proot = new_node; // 结点+1； add_size(); } return proot; } // 插入值比当前结点值还要小， 则应该插入到当前节点的左边 if (proot->data > data) { proot->lc = insert(proot->lc, data); } // 插入之比当前结点值还要打，则应该插入到当前结点的右边 else if (proot->data < data) { proot->rc = insert(proot->rc, data); } // 相等，则不插入结点。 return proot; } // size + 1 void add_size() { if (hmax_size_32767 == size) return ; size++; } // size - 1 void dec_size() { if ( hmin_size_0 == size) { return ; } size--; } private: // 根结点 node *root; // 当前树的结点个数 int size; }; // 测试代码 int main() { bstree tree; // tree.insert_node(50); tree.insert_node(30); tree.insert_node(10); tree.insert_node(0); tree.insert_node(20); tree.insert_node(40); tree.insert_node(70); tree.insert_node(90); tree.insert_node(100); tree.insert_node(60); tree.insert_node(80); // 前序遍历 cout << "前序遍历" << endl; tree.pre_order(); cout << endl; // 中序遍历 cout << "中序遍历" << endl; tree.in_order(); cout << endl; // 后序遍历 cout << "后序遍历" << endl; tree.post_order(); cout << endl; cout << "删除结点开始，结束请输入10086" << endl; int del_key = 0; while (true) { cout << "输入删除结点值 = "; cin >> del_key; if (10086 == del_key) break; tree.remove_node(del_key); cout << "删除后,结点个数 = " << tree.get_size() << endl; cout << "删除后， 中序遍历结果:" ;// << endl; tree.in_order(); cout << endl << endl; } tree.remove_all(); return 0; }
测试结果：
