二叉查找树_二叉搜索树csdn-CSDN博客

本文链接：https://blog.csdn.net/xinwen1995/article/details/45131905

#include <stdio.h>
#include <malloc.h>

typedef struct node *Position;
typedef int ElementT;

Position InsertValue(Position T,ElementT value);
Position Find(Position,ElementT);
Position FindMax(Position);
Position FindMin(Position);
ElementT DeleteTree(Position);    //此处要用ElementT
void PrintSortedTree(Position);
ElementT delete_leaf(Position T);  //<span style="font-family: Arial, Helvetica, sans-serif;">此处要用ElementT</span>
int Is_leaf(Position T);
int Is_root(Position T);

void Insert_node(Position,Position);

struct node
{
	ElementT element;
	Position parent;
	Position left;
    Position right;
}; 

int main()
{
	Position T=NULL;
	int c;
	printf("输入数字以0为结束:");
	while (~scanf("%d",&c),c)
	{
		T = InsertValue(T,c);
	}
	//---------------------------排序输出(升序)
	printf("排序后的所有值为:\n");
    PrintSortedTree(T);
	//---------------------------查找
	int value;
	Position Find_value;
	printf("输入要查找的数字为:");
	scanf("%d",&value);
	Find_value=Find(T,value);
	if(Find_value != NULL)
	    printf("%d\n",Find_value->element);
	else
		printf("未找到此元素\n");
	//---------------------------查找最小值
    printf("最小值为:");
    printf("%d\n",FindMin(T)->element);
	//---------------------------查找最大值
    printf("最大值为:");
    printf("%d\n",FindMax(T)->element);
	//---------------------------删除
    printf("要删除的数字为:"); 
	scanf("%d",&value);
	Position del;
	del = Find(T,value);
	if(del == NULL) printf("未找到此元素\n");
	else
	{ 
		DeleteTree(del);
	    PrintSortedTree(T);
	}
	return 0;
}

Position InsertValue(Position T,ElementT value)
{
    Position np;
	np=(Position)malloc(sizeof(node));
	np->element = value;
	np->left = NULL;
	np->right = NULL;
	np->parent = NULL;
	if (T == NULL)
    {
		T = np;
	}
	else
	{
        Insert_node(np,T);
	}
	return T;
}

Position Find(Position T,ElementT value)
{
	if(T == NULL) return NULL;
    if(value == T->element) return T;
	else
	{
		if (value < T->element)
		{
			Find(T->left,value);
		}
		else
			Find(T->right,value)                                                                                                                                             ;
	}
}

Position FindMin(Position T)
{
    if(T->left == NULL) return T;
	else
		FindMin(T->left);
}


Position FindMax(Position T)
{
    if(T->right == NULL) return T;
	else
		FindMax(T->right);
}

ElementT DeleteTree(Position del)    //删除树是最复杂的，考虑叶子的删除和不是叶子的删除
{
	Position temp;
	ElementT element;
	int flag=1;
	if (Is_leaf(del))
	{
		return delete_leaf(del);
	}
	else
	{
        temp = (del->left != NULL)?FindMax(del->left):FindMin(del->right);
        element = del->element;
		del->element = DeleteTree(temp);
		return element;
	}
}

ElementT delete_leaf(Position np)
{
     ElementT element;
	 Position parent;
	 element = np->element;
	 parent = np->parent;
	 if (!Is_root(np))
	 {
        if (parent->left == np)
        {
			parent->left=NULL;
        }
		else
		{
			parent->right = NULL;
		}
	 }
	 free(np);
	 return element;
}

void Insert_node(Position np,Position T) //并未修改T,一直指向根
{
    if (np->element <= T->element)
    {
		if (T->left == NULL)
		{
            T->left = np;
			np->parent = T;
			return ;//停止作用
		}
		else
		{
            Insert_node(np,T->left);
		}
    }
	else
	{
		if (T->right == NULL)
		{
			T->right = np;
			np->parent = T;
			return ;
		}
		else
		{
            Insert_node(np,T->right); 
		}
	}
}

int Is_leaf(Position T)
{
   return (T->left == NULL && T->right == NULL);
}

int Is_root(Position T)
{
	return (T->parent == NULL);
}


void PrintSortedTree(Position T)
{
    if(T == NULL ) return ;
	PrintSortedTree(T->left);
	printf("%d\n",T->element);
	PrintSortedTree(T->right);
}

方法2：

#include<iostream>
using namespace std;
typedef struct tree
{
    tree *l,*r;
    int num;
}tree;
tree *creat(int x)                         //建树
{
    tree *t=(tree *)malloc(sizeof(tree));
    t->l=0;
    t->r=0;
    t->num=x;
    return t;
}
tree *inster(tree *s,int x)               //插入结点
{
    if(s==NULL)                    
    {
        tree *t=creat(x);
        s=t;
    }
    else
    {
        if(x<=s->num)
            s->l=inster(s->l,x);
        else
            s->r=inster(s->r,x);
    }
    return s;
}
tree *findmin(tree *s)               //找tree的最小值（左子树最左边的为最小值）
{
    if(s==NULL)
        return NULL;
    else if(s->l==NULL)
        return s;
    else
        return findmin(s->l);
}
tree *del(tree *s,int x)        //在删除一个结点后，要有一个结点可以承接此结点位置的，要么取被删除结点右子树中最小的那个结点，
{                                  //要么取其左子树中最大的那个结点
    tree *t;
    if(s==NULL)
        return NULL;
    else if(x<s->num)
        s->l=del(s->l,x);
    else if(x>s->num)
        s->r=del(s->r,x);
    else
        if(s->l&&s->r)            //如果两个孩子都存在
        {
            t=findmin(s->r);       //找右子树中最小的那个结点
            s->num=t->num;
            s->r=del(s->r,s->num);
            return s;
        }
        else                       //只有一个孩子在，那么直接操作就好
        {
            t=s;
            if(s->l==NULL)
                s=s->r;
            else if(s->r==NULL)
                s=s->l;
            free(t);
        }
        return s;
}

//2015 - 10 -14

#include <iostream>
#include <cstring>
using namespace std;

//  二叉树   创建 插入  查找最小最大值   删除*

typedef struct tree {

	 tree *l;
	 tree *r;
	 int data;

}*ptree;

ptree creat(int data)
{
    ptree t = (ptree)malloc(sizeof(tree));
	t->l = NULL;
	t->r = NULL;
	t->data = data;
	return t;
}

ptree insert(ptree t,int data)
{
    if(t == NULL)
	{
		t = creat(data);
	}
	else
	{
		if(data <= t->data)
		{
            t->l = insert(t->l,data);
		}
		else
		{
			t->r = insert(t->r,data);
		}
	}
	return t;
}

ptree find_min(ptree t)
{
    if(t->l->l == NULL)
	{
		return t;
	}
	else
	{
		find_min(t->l);
	}
}

ptree find_max(ptree t)
{
	if(t->r->r == NULL)
	{
		return t;
	}
	else
	{
		find_min(t->r);
	}
}

//二叉树的删除是个难点
//原先不知道指针传参，在函数里修改是不能修改的，但是指针所取得值是可以修改的
//所以就需要一个父指针
ptree find(ptree p,int data,ptree root,ptree parent)
{
	//ptree root = p;
	ptree f;

    if(p->data == data)
	{
		if(p == root)   //删除头部
		{
			f = find_min(p->r);
            root->data = f->l->data;
			free(f->l);
			f->l = NULL;
		}
		else
		{
			if(p->l && p->r)  //中间的
			{
				if(parent->l->data == data)
				{
                    parent->l = p->l;
					parent->l->r = p->r;
				}
				else
				{
					parent->r = p->l;
					parent->r->r = p->r;
				}
			}
			else                  //尾部  
			{
				if(p->l == NULL  && p->r == NULL)
                {
					if(parent->l->data == data)
					{
						free(parent->l);
						parent->l = NULL;
					}
					else
					{
						free(parent->r);
						parent->r = NULL;
					}
				}
				else
				{
					if(parent->l->data == data)
					{
						if(p->l == NULL)
							parent->l = p->r;
						else
					        parent->l = p->l; 
					}
					else
					{
						if(p->l == NULL)
							parent->r = p->r;
						else
					        parent->r = p->l; 
					}

				}
			}
		}
	}
	else
	{
		if(data < p->data)
		{
            find(p->l,data,root,p);
		}
		else
		{
			find(p->r,data,root,p);
		}
	}
	return NULL;
}

int main()
{
	int data;
	cin>>data;

    ptree root = creat(data);//指针的初始化不能忘,要传参
    ptree t = root;

	while(cin>>data)
	{
	    t = insert(t,data);
	}
     
	t = find_min(root); //传出来的是父节点
	if(t)
		cout<<"最小值为: "<<t->l->data<<endl;

	cin.clear();
	cin.sync();
    cout<<"输入要删除的数字: ";
	cin>>data;
    find(root,data,root,root);

	t = find_min(root);
	if(t)
		cout<<"最小值为: "<<t->l->data<<endl;

	t = find_max(root);
	if(t)
		cout<<"最大值为: "<<t->r->data<<endl;

    //cout<<root->l->data<<"  "<<root->r->data<<endl;测试
	return 0;
}