二叉排序树的插入与删除

一、二叉排序树的插入

　　首先检查要插入的数据是否已存在，若存在则不插入，若不存在，则把元素插入到在二叉树上查找失败时的结点的左孩子和右孩子上。需要考虑的特殊情况是插入第一个元素前，二叉树为空。

　　

bool insert(BiTreeNode *&root,DataType *item) {
    BiTreeNode *current = NULL,*parent = NULL,*p = NULL;
    current = root;
    while(current != NULL) {
        if(current->data.key == item->key)return false;
        parent = current;
        if(current->data.key < item->key)
            current = current->rightChild;
        else
            current = current->leftChild;
    }
    p = new BiTreeNode;
    p->data = *item;

    //the new node is root node
    if(parent == NULL)
        root = p;
    //as leftChild
    else if(item->key < parent->data.key)
        parent->leftChild = p;
    //as rightChild
    else
        parent->rightChild = p;
    return true;
}

二、二叉排序树的删除

　　删除操作的要求是：首先检查要删除的元素是否存在，若不存在，直接返回若存在，理论上需要考虑2*4种情况。

　　a、要删除的节点为根节点。

　　b、要删除的节点不为根节点。

　　　　1、该节点无孩子节点。

　　　　　　sln1:直接删除该节点。

　　　　2、该节点只有左孩子节点。

　　　　　　sln2:被删除节点的父节点指向该节点的左孩子节点，被删除节点是其父节点的左节点还是右节点，亦或是根节点，则需要判断。

　　　　3、该节点只有右孩子节点。

　　　　　　sln3:类似sln2。

　　　　4、该节点有左、右孩子节点。

　　　　　　sln4:首先：寻找数据元素关键字大于要删除节点关键字的最小值，即要删除节点右子树的最左子树，例如为Kdata。

　　　　　　　　然后：把Kdata的数据赋给要删除的元素。

　　　　　　　　最后：以要删除元素的右子树为根节点，以Kdata为要删除的数据，递归调用删除算法。

bool deleteNode(BiTreeNode *&root,DataType item) {
    BiTreeNode *current = root,*parent = NULL,*p = NULL,*kmin = NULL;
    bool flag = false;
    //寻找要删除的节点和其父节点
    while(current != NULL) {
        if(current->data.key == item.key) {
            flag = true;
            break;
        }
        parent = current;
        if(current->data.key < item.key)
            current = current->rightChild;
        else current = current->leftChild;
    }
    //未找到要删除的元素
    if(flag == false) {
        cout<<"delete error:item not found"<<endl;
        return false;
    }
    if(current->leftChild == NULL) {
        p = current;
        if(parent != NULL) {
            if(parent->leftChild != NULL && parent->leftChild->data.key == current->data.key)
                parent->leftChild = current->rightChild;
            else parent->rightChild = current->rightChild;
        } else {
            root = current->rightChild;
        }
        delete p;
    } else if(current->rightChild == NULL) {
        p = current;
        if(parent != NULL) {
            if(parent->leftChild != NULL && parent->leftChild->data.key == current->data.key)
                parent->leftChild = current->leftChild;
            else parent->rightChild = current->leftChild;
        } else {
            root = current->leftChild;
        }
        delete p;
    } else {
        kmin = current->rightChild;
        while(kmin->leftChild != NULL) {
            kmin = kmin->leftChild;
        }
        if(parent != NULL)
            current->data = kmin->data;
        else
            root->data = kmin->data;
        deleteNode(current->rightChild,kmin->data);
    }
    return true;
}

完整测试代码：

#include <iostream>
#include <stdlib.h>
#include <stdio.h>

using namespace std;

struct DataType {
    int key;
};

typedef struct node {
    DataType data;
    struct node *leftChild;
    struct node *rightChild;
    node() {
        leftChild = NULL;
        rightChild = NULL;
    }
} BiTreeNode;

BiTreeNode *search(BiTreeNode *root,DataType item) {
    BiTreeNode *p = NULL;
    if(root!=NULL) {
        p = root;
        while(p!=NULL) {
            if(p->data.key == item.key)
                return p;
            if(item.key > p->data.key)
                p = p->rightChild;
            else
                p = p->leftChild;
        }
    }
    return NULL;
}

bool insert(BiTreeNode *&root,DataType *item) {
    BiTreeNode *current = NULL,*parent = NULL,*p = NULL;
    current = root;
    while(current != NULL) {
        if(current->data.key == item->key)return false;
        parent = current;
        if(current->data.key < item->key)
            current = current->rightChild;
        else
            current = current->leftChild;
    }
    p = new BiTreeNode;
    p->data = *item;

    //the new node is root node
    if(parent == NULL)
        root = p;
    //as leftChild
    else if(item->key < parent->data.key)
        parent->leftChild = p;
    //as rightChild
    else
        parent->rightChild = p;
    return true;
}

void inTraverse(BiTreeNode *root) {
    if(root == NULL) {
        cout<<"inTraverse error:root = NULL"<<endl;
        return;
    }
    if(root->leftChild != NULL)
        inTraverse(root->leftChild);
    cout<<root->data.key<<" ";
    if(root->rightChild != NULL)
        inTraverse(root->rightChild);
}

bool deleteNode(BiTreeNode *&root,DataType item) {
    BiTreeNode *current = root,*parent = NULL,*p = NULL,*kmin = NULL;
    bool flag = false;
    //寻找要删除的节点和其父节点
    while(current != NULL) {
        if(current->data.key == item.key) {
            flag = true;
            break;
        }
        parent = current;
        if(current->data.key < item.key)
            current = current->rightChild;
        else current = current->leftChild;
    }
    //未找到要删除的元素
    if(flag == false) {
        cout<<"delete error:item not found"<<endl;
        return false;
    }
    if(current->leftChild == NULL) {
        p = current;
        if(parent != NULL) {
            if(parent->leftChild != NULL && parent->leftChild->data.key == current->data.key)
                parent->leftChild = current->rightChild;
            else parent->rightChild = current->rightChild;
        } else {
            root = current->rightChild;
        }
        delete p;
    } else if(current->rightChild == NULL) {
        p = current;
        if(parent != NULL) {
            if(parent->leftChild != NULL && parent->leftChild->data.key == current->data.key)
                parent->leftChild = current->leftChild;
            else parent->rightChild = current->leftChild;
        } else {
            root = current->leftChild;
        }
        delete p;
    } else {
        kmin = current->rightChild;
        while(kmin->leftChild != NULL) {
            kmin = kmin->leftChild;
        }
        if(parent != NULL)
            current->data = kmin->data;
        else
            root->data = kmin->data;
        deleteNode(current->rightChild,kmin->data);
    }
    return true;
}

void createFile(int n) {
    FILE *fp = fopen("file.txt","w");
    while(n--) {
        fprintf(fp,"%d ",rand()%10000);
    }
    fclose(fp);
}

int *readFile(int n) {
    int *num = new int[n],i=0;
    FILE *fp = fopen("file.txt","r");
    while(!feof(fp)) {
        fscanf(fp,"%d ",&num[i++]);
    }
    return num;
}

int main() {
    BiTreeNode *root = NULL;
    int n = 100,*num = NULL,i;
    createFile(n);
    num = readFile(n);
    for(i=0; i<n; i++) {
        DataType x;
        x.key = num[i];
        insert(root,&x);
    }
    for(i=0; i<n; i++) {
        cout<<endl<<"del:"<<num[i]<<endl;
        DataType m;
        m.key = num[i];
        deleteNode(root,m);
        inTraverse(root);
    }
    //BiTreeNode *root = NULL;
    return 0;
}