二叉查找树

#include <iostream>
#include <stdlib.h>
using namespace std;

typedef struct tree
{
    int data;
    struct tree *left;
    struct tree *right;
    struct tree *prior;

}node;

void preorder_tree(node *head)
{
    if (head==NULL)
        return;

    cout<<head->data<<"";
    preorder_tree(head->left);
    preorder_tree(head->right);
}

void inorder_tree(node *head)
{
    if (head==NULL)
        return;

    inorder_tree(head->left);
    cout<<head->data<<"";
    inorder_tree(head->right);

}

void postorder_tree(node *head)
{
    if (head==NULL)
        return;

    postorder_tree(head->left);
    postorder_tree(head->right);
    cout<<head->data<<"";

}

node *tree_search(node *head,int key)        //递归查找元素
{
    if (head==NULL || key==head->data)
        return head;
    if (key<head->data)
        return tree_search(head->left,key);
    return tree_search(head->right,key);

}

node *iterative_tree_search(node *head,int key)            //非递归查找元素
{
    while (head!=NULL && key!=head->data)
    {
        if (key<head->data)
            head=head->left;
        else
            head=head->right;
    }
    return head;
}

node *tree_min(node *head)
{
    while (head->left!=NULL)
    {
        head=head->left;
    }
    return head;
}

node *tree_max(node *head)
{
    while (head->right!=NULL)
    {
        head=head->right;
    }
    return head;
}

node *tree_successor(node *head)
{
    node *y;
    y=(node*)malloc(sizeof(node));
    if (head->right!=NULL)
        return tree_max(head->right);
    y=head->prior;
    while (y!=NULL && head==y->right)
    {
        head=y;
        y=y->prior;
    }
    return y;

}

void tree_insert(node *head,node *element)
{
    node *y;
    node *x;
    y=(node*)malloc(sizeof(node));
    y=NULL;
    x=(node*)malloc(sizeof(node));
    x=head;
    while (x!=NULL)
    {
        y=x;
        if (element->data<x->data)
            x=x->left;
        else
            x=x->right;
    }

    element->prior=y;
    if (y==NULL)
        head=element;
    else if(element->data<y->data)
        y->left=element;
    else
        y->right=element;
}

node *tree_delete(node *head,node *element)
{
    node *y;
    node *x;
    y=(node*)malloc(sizeof(node));
    x=(node*)malloc(sizeof(node));
    if(element->left==NULL || element->right==NULL)
        y=element;
    else
        y=tree_successor(element);
    
    if(y->left!=NULL)
        x=y->left;
    else
        x=y->right;

    if(x!=NULL)
        x->prior=y->prior;
    
    if(y->prior==NULL)
        head=x;
    else if(y==y->prior->left)
        y->prior->left=x;
    else
        y->prior->right=x;

    if(y!=element)
    {
        element->data=y->data;
        element->prior=y->prior;
        element->right=y->right;
        element->left=y->left;
    }
    
    return y;
}

int main()
{
    int a[]={4,3,7,5,1,9,43,2,10,52,34};
    node *head;
    node *element[11];
    head=(node*)malloc(sizeof(node));
    head->data=6;
    head->right=NULL;
    head->left=NULL;
    head->prior=NULL;

    for (int i=0;i<11;i++)                        //这样建树不太好,浪费了,but it works
    {
        element[i]=(node*)malloc(sizeof(node));
        element[i]->data=a[i];
        element[i]->prior=NULL;
        element[i]->right=NULL;
        element[i]->left=NULL;    
        
        tree_insert(head,element[i]);
    }

    cout<<"前序："<<endl;
    preorder_tree(head);
    cout<<endl;
    
    cout<<"中序："<<endl;
    inorder_tree(head);
    cout<<endl;

    cout<<"后序："<<endl;
    postorder_tree(head);
    cout<<endl;

    cout<<"max is "<<tree_max(head)->data<<endl;
    cout<<"min is "<<tree_min(head)->data<<endl;
    free(head);
    for (int i=0;i<11;i++)
    {
        free(element[i]);
    }
    system("pause");
    return 0;
}