|| 二叉搜索树(Binary Search Tree)主要用于搜索和动态排序
|| 二叉搜索树的基本原理 :
声明:
class BTree {
private:
bool Empty;
int val;
BTree* Right;
BTree* Left;
public:
BTree() { Empty = true; }
BTree(BTree& t);
void Print();
//void Add(int val_new); //少用void,好程序用bool
bool Add(int val_new);
};
插入:
bool BTree::Add(int val_new) {
if (Empty == true) {
Empty = false;
val = val_new;
Left = new BTree();
Right = new BTree();
return true;
}
return (val_new == val) ? false : (val_new < val) ? Left->Add(val_new) : Right->Add(val_new);
}
查找:
BTree BTree::Search(int num) {
BTree t;
if (val == num) { t = BTree(*this); return t; }
if (Empty == true) { t = BTree(*this); return t; }
if (val > num) Left-> Search(num);
if (val < num) Right -> Search(num);
}
删除
遍历
void BTree::Print() {
if (Empty) return;
cout << val << " ";
Right->Print();
Left->Print();
}
#include "StdAfx.h"
struct Node {
int key;
int value;
// Node* parent;
Node* left;
Node* right;
};
Node* NewNode(int key, int value) {
Node* p = (Node*)malloc(sizeof(Node)); // 删除节点时要注意放掉内存
p->key = key;
p->value = value;
// p->parent = parent;
p->left = NULL;
p->right = NULL;
return p;
}
Node** nSearch(Node** n, int key) {
if (*n == NULL) {
return n;
}
else if (key == (*n)->key) {
return n;
}
else if (key < (*n)->key) {
return nSearch(&(*n)->left, key);
}
else {
return nSearch(&(*n)->right, key);
}
}
void nAdd(Node** r, int key, int value) {
Node** n = nSearch(r, key);
if (*n == NULL) {
*n = NewNode(key, value);
}
else {
(*n)->value = value;
}
}
int nGet(Node** n, int key) {
Node** result = nSearch(n, key);
if ((*result) == NULL) {
return NULL;
}
else {
return (*result)->value;
}
}
void nWalk(Node* n) {
if (n == NULL) {
return;
}
if (n->left != NULL) {
nWalk(n->left);
}
printf("%d\n", n->key);
if (n->right != NULL) {
nWalk(n->right);
}
}
Node** nMin(Node** n) {
if ((*n)->left == NULL) {
return n;
}
else {
return nMin(&(*n)->left);
}
}
Node** nSuccessor(Node** n) {
if ((*n)->right == NULL) {
return NULL;
}
else {
return nMin(&(*n)->right);
}
}
int nRemove(Node** n, int key) {
Node** d = nSearch(n, key);
if ((*d) == NULL) {
return -1; // 要删除的几点不存在
}
if ((*d)->left != NULL && (*d)->right != NULL) {
Node** suc = nSuccessor(d);
(*d)->key = (*suc)->key;
(*d)->value = (*suc)->value;
return nRemove(suc, (*suc)->key);
}
else {
// 因为使用二级指针,不在需要判断要删除的节点本身是处在左边还是右边,因为指针中已经指向了原始我们要修改的位置。
Node* d_child;
if ((*d)->left != NULL) {
d_child = (*d)->left;
// d_child->parent = (*d)->parent;
}
else if ((*d)->right != NULL) {
d_child = (*d)->right;
// d_child->parent = (*d)->parent;
}
else {
d_child = NULL;
}
free(*d);
// 同样的,这里也不再需要判断是不是根节点
*d = d_child;
return 0;
}
}
int main() {
int testData[20][2] = {
{61, 6161},
{30, 3030},
{98, 9898},
{3, 33},
{36, 3636},
{30, 3030},
{6, 66},
{54, 5454},
{63, 6363},
{93, 9393},
{93, 9393},
{76, 7676},
{84, 8484},
{16, 1616},
{13, 1313},
{76, 7676},
{78, 7878},
{29, 2929},
{9, 99},
{76, 7676}
};
Node* root = NULL;
Node** rootP = &root;
int i;
for (i = 0; i < 20; i++) {
nAdd(rootP, testData[i][0], testData[i][1]);
}
nWalk(root);
for (i = 0; i < 20; i++) {
nRemove(rootP, testData[i][0]);
}
printf("\n\n");
nWalk(root);
return 0;
}
class Node(object):
def __init__(self, key, data, parent=None):
self.key = key
self.data = data
self.parent = parent
self.left = None
self.right = None
def add_child(self, key, data):
if key == self.key:
self.data = data
return
elif key < self.key:
if self.left is None:
self.left = Node(key, data, self)
else:
self.left.add_child(key, data)
else:
if self.right is None:
self.right = Node(key, data, self)
else:
self.right.add_child(key, data)
def get(self, key):
if key == self.key:
return self
elif key < self.key:
if self.left is None:
return None
else:
return self.left.get(key)
else:
if self.right is None:
return None
else:
return self.right.get(key)
def get_data(self, key):
r = self.get(key)
if r is None:
return None
else:
return r.data
def in_order_walk(self):
if self.left is not None:
self.left.in_order_walk()
print(self.key)
if self.right is not None:
self.right.in_order_walk()
def get_max(self):
if self.right is None:
return self
else:
return self.right.get_max()
def get_min(self):
if self.left is None:
return self
else:
return self.left.get_min()
def predecessor(self):
if self.left is not None:
return self.left.get_max()
else:
return None
def successor(self):
if self.right is not None:
return self.right.get_min()
else:
return None
def remove(self, key):
d = self.get(key)
if not d.left and not d.right:
if d.parent is None:
# self = None
return
elif d.parent.left == d:
d.parent.left = None
else:
d.parent.right = None
elif bool(d.left) is not bool(d.right):
if d.left:
if d.parent.left == d:
d.parent.left = d.left
d.left.parent = d.parent
else:
d.parent.right = d.left
d.left.parent = d.parent
else:
if d.parent.right == d:
d.parent.right = d.right
d.right.parent = d.parent
else:
d.parent.left = d.right
d.right.parent = d.parent
else:
successor = d.successor()
d.key = successor.key
d.data = successor.data
successor.remove(successor.key)
class Tree(object):
def __init__(self, root):
self.root = root
def remove(self, key):
d = self.root.get(key)
if d.left and d.right:
successor = d.successor()
d.key = successor.key
d.data = successor.data
d = successor
else:
pass
if d.left:
d_child = d.left
d_child.parent = d.parent
elif d.right:
d_child = d.right
d_child.parent = d.parent
else:
d_child = None
if d.parent:
if d.parent.left == d:
d.parent.left = d_child
else:
d.parent.right = d_child
else:
self.root = None
def in_order_walk(self):
if self.root:
self.root.in_order_walk()
else:
print(None)
def __getattr__(self, item):
return getattr(self.root, item)
def main():
data_list = [
[20, 2222],
[30, 3333],
[40, 4444],
[50, 5555],
[60, 6666],
[70, 7777],
[80, 8888],
[90, 9999],
]
middle = data_list[5]
tree = Tree(Node(middle[0], middle[1]))
for i in data_list:
tree.root.add_child(i[0], i[1])
tree.add_child(1, 111)
tree.remove(70)
tree.in_order_walk()
if __name__ == '__main__':
main()
参考:https://www.jianshu.com/p/6e05da24905b