二叉查找树的4个变种

DelBST1  递归实现 直接删点

DelBST2 递归实现 换值删点

DelBST3 非递归实现 直接删点

DelBST4 非递归实现 换值删点

文中所有代码暂时未进行编译若有小错误请见谅

#include <bits/stdc++.h>
using namespace std;
#define  KeyType  int
#define ENDKEY -1
typedef struct node{
    KeyType key;
    struct node *lchild, *rchild;
}BSTNode, *BSTree;
void InsertBST(BSTree *bst, KeyType key){
    BSTree s;
    if(*bst == NULL){
        s = (BSTree)malloc(sizeof(BSTNode));
        s->key = key;
        s->lchild = NULL;
        s->rchild = NULL;
        *bst = s;
    }
    else if(key < (*bst)->key)
        InsertBST(&((*bst)->lchild), key);
    else if(key > (*bst)->key)
        InsertBST(&((*bst)->rchild), key);
}
void creatBST(BSTree *bst){
    KeyType key;
    *bst = NULL;
    cin>>key;
    while(key != ENDKEY){
        InsertBST(bst, key);
        cin>>key;
    }
}
BSTree SearchBST(BSTree bst, KeyType key){
    if(!bst)
        return NULL;
    else if(bst->key == key)
        return bst;
    else if(bst->key > key)
        return SearchBST(bst->lchild, key);
    else
        return SearchBST(bst->rchild, key);
}
//递归写法1
BSTNode *DelBST(BSTree t, KeyType k){
    if(k > t->key){
        return t->rchild = DelBST(t->rchild, k);
    }
    else if( k < t->key)
        return t->lchild = DelBST(t->lchild, k);
    else{
        if(t->rchild == NULL){
            return t->lchild;
        }
        if(t->lchild == NULL){
            return t->rchild;
        }
        BSTNode *p = t->lchild, *fp = p;
        //find the biggest number in point t Left tree
        while(p->rchild){
            fp = p;
            p = p->rchild;
        }
        if(t->lchild != p){
       fp->rchild = NULL;
        p->lchild = t->lchild;
        p->rchild = t->rchild;
        }
        p->rchild = t->rchild;
        free(t);
        return p;
    }
}
//递归写法2（值交换
BSTNode *DelBST2(BSTree t, KeyType k){
    if(k > t->key){
        return t->rchild = DelBST2(t->rchild, k);
    }
    else if( k < t->key)
        return t->lchild = DelBST2(t->lchild, k);
    else{
        if(t->rchild == NULL){
            return t->lchild;
        }
        if(t->lchild == NULL){
            return t->rchild;
        }
        BSTNode *p = t->lchild, *fp;
        //find the biggest number in point t Left tree
        while(p->rchild){
            fp = p;
            p = p->rchild;
        }
        if(t->lchild != p){
            fp->rchild = p->lchild;
        }
        t->lchild = p->lchild;
        t->key = p->key;
        free(p);
        return t;
    }
}
//非递归
BSTNode *DelBST3(BSTree t, KeyType k){
        BSTree *p, *fp = nullptr;
        p = t;
        while(p){
            if(p->key < k){
                fp = p;
                p = p->rchild;
            }
            else if(p->key > k){
                fp = p;
                p = p->lchild;
            }
            else
                break;
        }
        if(p == nullptr)
            return t;

        if(p->lchild == nullptr){
            if(fp == nullptr){
                fp = p->rchild;
                free(p);
                return fp;
            }
            else if(fp->lchild == p){
                fp->lchild = p->rchild;
                free(p);
                return t;
            }
            else if(fp->rchild == p){
                fp->rchild = p->rchild;
                free(p);
                return t;
            }
        }
        if(p->rchild == nullptr){
            if(fp == nullptr){
                fp = p->lchild;
                free(p);
                return fp;
            }
            else if(fp->lchild == p){
                fp->lchild = p->lchild;
                free(p);
                return t;
            }
            else if(fp->rchild == p){
                fp->rchild = p->rchild;
                free(p);
                return t;
            }
        }
       //find the biggest number in left Tree
       BSTree *tmp = p->lchild, *tmp2;
       while(tmp->rchild){
            tmp2 = tmp;
            tmp = tmp->rchild;
       }
       if(tmp != tmp2){
        tmp2->rchild = nullptr;
        tmp->lchild = p->lchild;
        tmp->rchild = p->rchild;
       }
        tmp->rchild = p->rchild;
        free(p);
        return t;

}
BSTNode *DelBST4(BSTree t, KeyType k){
        BSTree *p, *fp = nullptr;
        p = t;
        while(p){
            if(p->key < k){
                fp = p;
                p = p->rchild;
            }
            else if(p->key > k){
                fp = p;
                p = p->lchild;
            }
            else
                break;
        }
        if(p == nullptr)
            return t;

        if(p->lchild == nullptr){
            if(fp == nullptr){
                fp = p->rchild;
                free(p);
                return fp;
            }
            else if(fp->lchild == p){
                fp->lchild = p->rchild;
                free(p);
                return t;
            }
            else if(fp->rchild == p){
                fp->rchild = p->rchild;
                free(p);
                return t;
            }
        }
        if(p->rchild == nullptr){
            if(fp == nullptr){
                fp = p->lchild;
                free(p);
                return fp;
            }
            else if(fp->lchild == p){
                fp->lchild = p->lchild;
                free(p);
                return t;
            }
            else if(fp->rchild == p){
                fp->rchild = p->rchild;
                free(p);
                return t;
            }
        }
       //find the biggest number in left Tree
       BSTree *tmp = p->lchild, *tmp2;
       while(tmp->rchild){
            tmp2 = tmp;
            tmp = tmp->rchild;
       }
       if(tmp != p->lchild){
            tmp2->rchild = tmp->lchild;
       }
       p->lchild = tmp->lchild;
       p->key = tmp->key;
       return t;
}

 

转载于:https://www.cnblogs.com/19990219073x/p/10117285.html