数据结构与算法之美链表练习

简单的单向链表

template<typename T>
class SingleList
{
public:
    Node<T>* pHead;
public:
    SingleList()=default;
    SingleList(T d):pHead(new Node<T>(d)){};
    //增
    void addNode(T val)
    {
        if(!pHead)
            pHead = new Node<T>(val);
        else
        {
            auto head = pHead;
            while(head->next)
                head = head->next;
            head->next = new Node<T>(val);
        }
    };

    //删
    void deleteNode(T val)
    {
        if (!pHead)
            return;
        if (pHead->data == val)
        {
            auto node = pHead;
            pHead = pHead->next;
            delete node;
            return;
        }
        auto head = pHead;
        auto preNode = pHead;
        while(head)
        {
            auto node = head;
            if(node->data == val)
            {
                preNode->next = node->next;
                head = node->next;
                preNode = head;
                delete node;
            }
            else
            {
                preNode = head;
                head = head->next;
            }
        }
    };
    //链表反转
    void reverse()
    {
        Node<T>* node = nullptr;
        while(pHead)
        {
            auto head = pHead;
            pHead = pHead->next;
            head->next = node;
            node = head;
        }
        pHead = node;
    };

};
//实现求链表的中间节点,因为省略了很多接口，导致这里的代码很难看
template<typename T>
Node<T>* getMidNode(SingleList<T>& a)
{
    int nCount = 0;
    auto head = a.pHead;
    if(!head)
        return nullptr;
    while(head)
    {
        nCount++;
        head = head->next;
    }
    head = a.pHead;
    auto delay = a.pHead;
    int nMid = nCount/2;
    while(nMid--)
        head = head->next;
    while (head->next!=NULL)
    {
        head = head->next;
        delay = delay->next;
    }
    
    return delay;
}
//实现2个有序的链表合成一个有序的链表,归并就好了
template<typename T>
SingleList<T> concat(SingleList<T>& a,SingleList<T>& b)
{
    if(!a.pHead)
        return b;
    if(!b.pHead)
        return a;
    auto aHead = a.pHead;
    auto bHead = b.pHead;
    T t;
    if(aHead->data >= bHead->data)
    {
        t = bHead->data;
        bHead = bHead->next;
    }
    else
    {
        t = aHead->data;
        aHead = aHead->next;
    }
    
    SingleList<T> result(t);
    while (aHead && bHead)
    {
        if(aHead->data >= bHead->data)
        {
            result.addNode(bHead->data);
            bHead = bHead->next;
        }
        else
        {
            result.addNode(aHead->data);
            aHead = aHead->next;
        }
    }
    while (aHead)
    {
        result.addNode(aHead->data);
        aHead = aHead->next;
    }
    while(bHead)
    {
        result.addNode(bHead->data);
        bHead = bHead->next;
    }
    return result;
}

简单的双向链表

template<typename T>
class DoubleList
{
public:
    DoubleList()=default;
    DoubleList(T d):pHead(new NodeEx<T>(d)){};
    //增
    void addDoubleListPre(T d)
    {
        if(!pHead)
            pHead = new NodeEx<T>(d);
        else
        {
            auto head = pHead;
            while (head->pre)
                head = head->pre;
            NodeEx<T>* node = new NodeEx<T>(d);
            node->next = head;
            head->pre = node;
            pHead = node;
        }
    }
    
    void addDoubleListNext(T d)
    {
        if(!pHead)
            pHead = new NodeEx<T>(d);
        else
        {
            auto head = pHead;
            while(head->next)
                head = head->next;
            head->next = new NodeEx<T>(d);
        }
    }

    //删除
    void deleteDoubleList(T d)
    {
        if(!pHead)
            return;
        if(pHead->data == d)
        {
            auto node = pHead;
            pHead = pHead->next;
            delete node;
            return;
        }
        auto head = pHead;
        while (head)
        {
            if(head->data == d)
            {
                auto node = head;
                head->pre->next = head->next;
                node->next->pre = head->pre;
                delete node;
                return;
            }
            head = head->next;
        }
    }

private:
    NodeEx<T>* pHead;
};

简单的环型链表 —基于双向链表的结构

//环型链表
template<typename T>
class CircleList
{
public:
    CircleList(T d):pHead(new NodeEx<T>(d))
    {
        pHead->next = pHead;
    };
    void addCirCleNode(T d)
    {
        auto head = pHead;
        while(head->next != pHead)
            head = head->next;
        head->next = new NodeEx<T>(d);
        head->next->next = pHead;
    };

    void deleteLastNode()
    {
        if (pHead->next == pHead)
        {
            delete pHead;
            pHead = NULL;
            return;
        }
        auto preNode = pHead;
        auto head = pHead;
        while (head->next != pHead)
        {
            preNode = head;
            head = head->next;
        }
        preNode->next = pHead;
    };
private:
    NodeEx<T>* pHead;    
};

代码写的不好，还在进步中，最近在看《Efficientive C++》第三版，所以学习了很多思想，但是感觉还是需要多用代码实现一下，加油，龟速进步的憨憨程序员！！