使用C++模版实现的二叉查找树和链表

一直以来对算法啊，数据结构神马的最害怕了，没办法，既然是选择计算机这个专业，这些都是必须的基本功，有人称其为内功，我觉得很正确。为了提高我的内功，最近开始啃买了两年就看了不到100页的《算法导论》，今天看到了数据结构这几章，就用C++模版实现了链表和二叉搜索树，比较简单就当是复习C++模版了。

template <class T> struct Node
{
    T data;
    Node *next;
};


template <class T> class MyList
{    
 private:
    Node<T> *pHead;
 public:
    MyList(){
        pHead = NULL;
    }

    Node* GetHead()
    {
        return pHead;
    }

    void SetHead(Node *head)
    {
        this->pHead = head;
    }
    void InsertNode(T value);
    void PrintAll();
    void ReverseList();
    MyList<T> MergeList(MyList<T> list);
};

template <class T> MyList<T> MyList<T>::MergeList(MyList<T> list)
{
    MyList<T> newList;
    Node<T>* head1, *head2;
    head1 = pHead;
    head2 = list.pHead;
    while (head1!=NULL && head2!=NULL)
    {
        if (head1->data>head2->data)
        {
            newList.InsertNode(head2->data);
            head2 = head2->next;
        }else
        {
            newList.InsertNode(head1->data);
            head1 = head1->next;
        }
    }
    while (head1!=NULL)
    {
        newList.InsertNode(head1->data);
        head1 = head1->next;
    }

    while (head2!=NULL)
    {
        newList.InsertNode(head2->data);
        head2 = head2->next;
    }
    return newList;
}

template <class T> void MyList<T>::ReverseList()
{
    Node<T> *Current=NULL, *Next = NULL, *temp;
    Current = pHead;
    while (NULL != Current)
    {
        temp = Current->next;
        Current->next = Next;
        Next = Current;
        Current = temp;
    }
    pHead = Next;
}

template <class T> void MyList<T>::InsertNode(T value)
{
    Node<T> *node = new Node<T>;
    node->data = value;
    node->next = NULL;
    
    if (NULL == pHead)
    {
        pHead = node;
    }else
    {
        Node<T> *temp = pHead;
        while (temp->next!=NULL)
        {
            temp = temp->next;
        }
        temp->next = node;
    }
}

template<class T> void MyList<T>::PrintAll()
{
    Node<T> *pNode = pHead;
    while (NULL != pNode)
    {
        cout << pNode->data << " ";
        pNode = pNode->next;
    }
    cout << endl;
}

二叉查找树

#include <stack>

template <class T> struct Node 
{
    Node *pleft;
    Node *pright;
    Node *parent;
    T value;
};

template <class T> class BST
{
private:
    
public:
    Node<T> *root;
    BST(){
        root = NULL;
    }
    void InsertNode(T value);
    void InOrderTree(Node<T> *root);
    Node<T>* SearchNode(T value);
    Node<T>* TreeMin(Node<T>* node){
        Node<T> *temp = node;
        while (temp->pleft!=NULL)
        {
            temp = temp->pleft;
        }
        return temp;
    }
    T TreeMax(){
        Node<T> *temp = root;
        while (temp->pright != NULL)
        {
            temp = temp->pright;
        }
        return temp->value;
    }
    Node<T>* NodeSuccessor(Node<T>* node){
        if(node->pright!=NULL)
            return TreeMin(node->pright);
        Node<T>* p=node->parent;
        while (p!=NULL && p->pright == node)//p是node的最低祖先节点且p的左儿子也是node的祖先
        {                                    //这里使用p->pringht是满足这个就继续寻找的意思，也就是不应该满足p->right.
            node = p;
            p = p->parent;
        }
        return p;
    }

    Node<T>* DeleteNode(Node<T>* delNode)
    {
        Node<T>* temp = NULL, *x = NULL;
        //找到要删除的结点temp，当delnode至多只有一个子女时temp=delnode, 有两个子女时temp为delnode的后继
        if (delNode->pleft == NULL || NULL == delNode->pright)
        {
            temp = delNode;
        }else
            temp = NodeSuccessor(delNode);
        //找到temp的非空子女，此时的temp只可能有一个子女，当temp无子女时置为NULL
        if(temp->pleft!=NULL)
            x = temp->pleft;
        else
            x = temp->pright;

        //当x不为空的时候这时候不只是简单的删除temp就可以了，还要将temp->Parent与X连接起来
        //这里是X到temp->Parent的链接,a   
        //这时需要将C连到a             /
        //                             b
        //                             \
        //                              c   相当于画从下到上的箭头
        if(x!=NULL)
            x->parent = temp->parent;

        //需要删除的结点的父节点为空的时候，也就是要删除根节点，这时将temp的子女作为根节点
        if(temp->parent == NULL)
            root = x;
        else{//不为空时判断temp是左子女还是右子女，画从上到下的箭头
            if (temp == temp->parent->pleft)
            {
                temp->parent->pleft = x;
            }else{
                temp->parent->pright = x;
            }
        }
        
        //当要删除的节点与temp不相等时，也就是当delNode有两个子女时，将temp的值赋于delNode，
        //这时候树结构调整已经结束，只剩下只调整。
        if (temp != delNode)
        {
            delNode->value = temp->value;
        }    
        return temp;
    }
};
template<class T> Node<T>* BST<T>::SearchNode(T value)
{
    Node<T> *temp = root;
    while (temp!=NULL)
    {
        if (value == temp->value)
        {
            break;
        }
        if(value > temp->value)
            temp = temp->pright;
        else
            temp = temp->pleft;
    }
    return temp;
}

template<class T> void BST<T>::InOrderTree(Node<T> *root)
{
//     if(root != NULL)   //递归的中序遍历
//     {
//         InOrderTree(root->pleft);
//         cout << root->value << " ";
//         InOrderTree(root->pright);
//     }

    //利用栈进行中序遍历，就是不断地将左子树压栈直到最左子女为止，这时从栈中弹出栈顶元素（其实就是最左子女）
    //并输出该元素的值，然后若其有子女不为空将其有子女压栈（其实就是先解决以这个右子女为根节点的子树）
    stack<Node<T>*> st;
    while (root!=NULL || !st.empty())
    {
        while (root!=NULL)
        {
            st.push(root);
            root = root->pleft;
        }
        if (!st.empty())
        {
            Node<T>* node = st.top();
            st.pop();
            cout << node->value << " ";
            root = node->pright;
        }
    }
}

template<class T> void BST<T>::InsertNode(T value)
{
    Node<T> *node = new Node<T>;
    node->parent = NULL;
    node->pleft = NULL;
    node->pright = NULL;
    node->value = value;

    Node<T> *p = NULL, *temp=root;
    while (temp != NULL)
    {
        p = temp;
        if(value < temp->value)
            temp = temp->pleft;
        else
            temp = temp->pright;
    }
    node->parent = p;
    if (p==NULL)
    {
        root = node;
    }else
    {
        if(value > p->value)
            p->pright = node;
        else
            p->pleft = node;
    }
}

下面是测试二叉查找树的代码

int main(int argc, char* argv[])
{
    BST<int> bst;
    bst.InsertNode(3);
    bst.InsertNode(5);
    bst.InsertNode(4);
    bst.InsertNode(2);
    bst.InsertNode(1);

    bst.InOrderTree(bst.root);
    Node<int>* node = bst.SearchNode(3);
    cout << endl;
    cout << node->value << endl;
    bst.DeleteNode(node);
    bst.InOrderTree(bst.root);
    //cout << bst.NodeSuccessor(node)->value << endl;
    return 0;
}