二叉搜索树

一、查找

1.在二叉查找树中的查找是否存在一个元素

尾递归就是程序分支的最后（程序要返回的时候的递归，效率不高）

效率更好的实现：

2. 查找最大或者是最小的元素

二、插入和删除

自己写的插入算法：

#include<iostream>
using namespace std;
class binnode { 
public:
	binnode(int value=NULL):val(value) {
		
		leftchild = NULL;
		rightchild = NULL;
	}
	int val;
	binnode* leftchild;
	binnode* rightchild;
};
binnode* insert(binnode*head, binnode*pnew);
void inorder_digui(const binnode*root);//中序遍历（递归）
void inorder_digui(const binnode*root) {
	if (root) {

		inorder_digui(root->leftchild);
		cout << root->val << endl;
		inorder_digui(root->rightchild);
	}
}
binnode*  insert(binnode*head, binnode*pnew) {
	if (head == NULL)
	{
		head = pnew;
		return head;
	}
	if (pnew == NULL)
		return head;
	binnode*temp = head;
	binnode*pre = new binnode();
	while(head){
		if (pnew->val < head->val)
		{
			pre = head;
			head = head->leftchild;
		}
		else if (pnew->val > head->val) {
			pre = head;
			head = head->rightchild;
		}		
	}
	if (pnew->val > pre->val)
	{
		pre->rightchild = pnew;
	}
	else if (pnew->val < pre->val)
	{
		pre->leftchild = pnew;
	}
	return temp;
}

int main() {
	binnode*head = new binnode(4);

	binnode*node1 = new binnode(3);
	binnode*node2= new binnode(5);
	binnode*node3= new binnode(6);
	binnode*node4 = new binnode(2);



	bintree tree1;
	head = tree1.insert(head, node1);
	head = tree1.insert(head, node2);
	head = tree1.insert(head, node3);
	head = tree1.insert(head, node4);
	tree1.inorder_digui(head);
	return 0;
}

递归算法实现：

删除

笔记

要删除的结点分为三种情况：

1. 叶子结点
2. 只有左子节点或者右子节点的结点
3. 左孩子和有孩子都有的结点
   对于第三种情况
   
   

代码部分

#include<iostream>
#include<stack>
#include<queue>
#include<assert.h>
#include<string>
using namespace std;
class binnode { 
public:
	binnode(int value=NULL):val(value) {
		
		leftchild = NULL;
		rightchild = NULL;
	}
	int val;
	binnode* leftchild;
	binnode* rightchild;
};
class bintree {
public:
	void preorder(const binnode*root);//前序遍历（非递归）
	void inorder(const binnode*root);//中序遍历（非递归）
	void postorder(const binnode*root);//后序遍历（非递归）
	void preorder_digui(const binnode*root);//前序遍历（递归）
	void inorder_digui(const binnode*root);//中序遍历（递归）
	int postorder_digui(const binnode*root);//后序遍历（递归）
	void levelorder(const binnode*root);//层序遍历
	binnode* insert(binnode*head, binnode*pnew);
	binnode* delete_m(binnode*head, int X);
	binnode* find(binnode*head, int X);
	int findmin(const binnode*root);
};
int bintree::findmin(const binnode*head) {
	binnode*temp = new binnode;
	temp->val = head->val;
	temp->leftchild = head->leftchild;
	temp->rightchild = head->rightchild;
	while (temp->leftchild) {
		temp = temp->leftchild;
	}
	int value = temp->val;
	free(temp);
	return value;
}
binnode* bintree::delete_m(binnode*head, int X) {
	if (!head) {
		cout << "没有找到这个值" << endl;
		return NULL;
	}
	if (X<head->val) {
		head->leftchild = delete_m(head->leftchild, X);
	}
	else if (X>head->val) {
		head->rightchild = delete_m(head->rightchild, X);
	}
	else {
		if (head->leftchild&&head->rightchild) {
			int temp = findmin(head->rightchild);
			head->val = temp;
			head->rightchild = delete_m(head->rightchild, temp);
		}
		else {
			if (!head->leftchild) {
				head=head->rightchild;
			}
			else if (!head->rightchild) {
				head = head->leftchild;
			}	
		}
	}
	return head;
}
int main() {
	binnode*head = new binnode(4);

	binnode*node1 = new binnode(3);
	binnode*node2= new binnode(5);
	binnode*node3= new binnode(6);
	binnode*node4 = new binnode(2);



	bintree tree1;
	head = tree1.insert(head, node1);
	head = tree1.insert(head, node2);
	head = tree1.insert(head, node3);
	head = tree1.insert(head, node4);
	tree1.inorder_digui(head);
	binnode*newp1,*newp2 = tree1.find(head, 5);
	tree1.delete_m(head, 2);
	tree1.inorder_digui(head);
	return 0;
	}