二叉搜索树之二

二叉查找树的删除情况

（1） 结点p无左右子树，则直接删除该结点，修改父节点相应指针

（2）结点p有左子树（右子树），则把p的左子树（右子树）接到p的父节点上

（3） 左右子树同时存在，则有三种处理方式

1>

找到结点p的中序直接前驱结点s，把结点s的数据转移到结点p，然后删除结点s，由于结点s为p的左子树中最右的结点，因而s无右子树，删除结点s可以归结到情况(2)。

2>
找到结点p的中序直接后继结点s，把结点s的数据转移到结点p，然后删除结点s，由于结点s为p的右子树总最左的结点，因而s无左子树，删除结点s可以归结到情况(2)
3>
找到p的中序直接前驱s，将p的左子树接到父节点上，将p的右子树接到s的右子树上，然后删除结点p。

#include <iostream>
#include <malloc.h>
using namespace std;
struct node{
    int data;
    node *left;
    node *right;
    node  *parent;
};

void insert(node *root,int data)
{
    node *p=(node *)malloc(sizeof(node));
    p->data=data;
    p->left=NULL;
    p->right=NULL;
    p->parent=NULL;
    if(root==NULL)
    {
    root->data=p->data;
    root->left=p->left;
    root->parent=p->parent;
    root->right=p->right;
}
    if(data>root->data)
     {
        insert(root->right,data);
    }
    else if(data<root->data)
     {
        insert(root->left,data);
    }
    else    
     {
    root->data=p->data;
    root->left=p->left;
    root->parent=p->parent;
    root->right=p->right;
   }
}
node* search(node *root,int data)
{
    node *p=(node *)malloc(sizeof(node));
    p->data=data;
    if(!root)
    return NULL;
    if(root->data>data)
    {
        search(root->right,data);
    }
    else if(root->data<data)
    {
        search(root->left,data);
    }
    else
        return root;
}
node* search_min(node *root)
{
    node *p=(node *)malloc(sizeof(node));
    if(root==NULL)
        return NULL;
    if(root->left)
    {
        p=search_min(root->left);
    }
    else
        return p;
}
node* search_max(node *root)
{
    node *p=(node *)malloc(sizeof(node));
    if(root==NULL)
        return NULL;
    if(root->right)
    {
        p=search_max(root->right);
    }
    else
        return p;
}
node* nextnode(node *root,int data)
{
    node *p=(node *)malloc(sizeof(node));
    p=search(root,data);
    if(p->right)
    {
        p=search_min(p->right);
    }
    else if(p->parent->left==p)
    {
         p=p->parent;
    }
    else
        p=NULL;
    return p;
}
node* prenode(node *root,int data)
{
   node *p=(node *)malloc(sizeof(node));
    p=search(root,data);
    if(p->left)
    {
        p=search_max(root->left);
    }
    else  if(p->parent->right==p )
    {
             p=p->parent;
      }
      else
        p=NULL;
    return p;
}
void deletenode(node *root,int data)
{
    node *p=(node *)malloc(sizeof(node));
    node *q;
    p=search(root,data);
    if(!p->left&&!p->right)
    {
      if(!p->parent)
       {
        delete(p);
        root=NULL;
       }
       else if(p->parent->right==p)
        {

            p->parent->right=NULL;
            delete(p);
}
       else if(p->parent->left==p)
       {
        p->parent->left=NULL;
        delete(p);
       }
}
      if(p->left&&!p->right)
      {
        if(!p->parent)
       {
        root=p->left;
        delete(p);
       }
       else if(p->parent->left==p)
        p->parent->left=p->left;
       else if(p->parent->right==p)
        p->parent->right=p->left;
      }
      if(!p->left&&p->right)
      {
        if(!p->parent)
        {
            root=p->right;
            delete(p);
        }
        else if(p->parent->left==p)
        p->parent->left=p->right;
       else if(p->parent->right==p)
        p->parent->right=p->right;
      }
      if(p->left&&p->right)
      {
        if(!p->parent)
        {
            p=search_min(p->right);
            if(p->parent->left==p)
                p->parent->left=NULL;
             else 
               p=p->right;
              root=p;
        }
        else if(p->parent->left==p)
        {

            q=search_min(p->right);


                 if(q->parent->left==q)
                {
                    q->parent->left=NULL;
                     p->parent->left=q;
                     q->right=p->right;
                     p->parent->left->left=p->left;
                     delete(p);
                }
             else 
               {
                q=q->right;
                p->parent->left=q;
                p->parent->left->right=p->right->right;
                p->parent->left->left=p->left;

        }
    }
        else if(p->parent->right==p)
        {
             q=search_min(p->right);
             if(q->parent->right==q)

                {
                    q->parent->left=NULL;
                     p->parent->right=q;
                     q->right=p->right;
                     p->parent->right->left=p->left;
                     delete(p);
                }
             else 
               {
                q=q->right;
                p->parent->right=q;
                p->parent->right->right=p->right->right;
                p->parent->right->left=p->left;
        }
      }
  }
}
 int vi(node *root)
 {
    if(root==NULL)
        return NULL;
    if(root)
    if(root->left)
      vi(root->left);
     cout<<root;
     if(root->right)
      vi(root->right);
 }
int main()
{
   node *p;
   int n;
   int a[100];

   cin>>n;
   for(int i=0;i<n;i++)
       {
         cin>>a[i];
        insert(p,a[i]);
}     
      vi(p);
     deletenode(p,3);
      vi(p);
     deletenode(p,4);
     vi(p);
return 0;
}

靠，老子写了两小时就是没编译成功，mamaipi
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;