c++鏈表-雙向鏈表+增刪查改

基於雙向鏈表的增刪改查和排序（C++實現）

雙向鏈表也叫雙鏈表，是鏈表的一種，它的每個數據結點中都有兩個指針，分別指向直接后繼和直接前驅。所以，從雙向鏈表中的任意一個結點開始，都可以很方便地訪問它的前驅結點和后繼結點。一般我們都構造雙向循環鏈表。

由於雙向鏈表可以方便地實現正序和逆序兩個方向的插入、查找等功能，在很多算法中經常被使用，

這里用C＋＋構造了一個雙向鏈表，提供了對雙向鏈表的插入、查找、刪除節點、排序等功能，其中排序提供了插入排序和冒泡排序兩種方式

#include<iostream>

using namespace std;

class Node          //組成雙向鏈表的節點
{
public:
    int data;
    Node * pNext;
    Node * pLast;
};

class List      //構造一個雙向鏈表
{
private:
    Node * pHead;
    Node * pTail;
    int length;
public:
    List(int length)//創建雙向鏈表
    {
        this->length = length;
        pHead = new Node();
        pHead->pLast = NULL;
        pTail = pHead;
        for (int i = 0; i < length; i++)
        {
            Node * temp = new Node();
            cout << "please enter the no" << i + 1 << " Node's data:";
            cin >> temp->data;
            temp->pNext = NULL;
            temp->pLast = pTail;
            pTail->pNext = temp;
            pTail = temp;
        }
    }

    void traverseList()//正向遍歷
    {
        Node * p = pHead->pNext;
        while (p != NULL)
        {
            cout << p->data << endl;
            p = p->pNext;
        }
    }

    void traverseListReturn()//逆向遍歷
    {
        Node * p = pTail;
        while (p->pLast != NULL)
        {
            cout << p->data << endl;
            p = p->pLast;
        }
    }

    void sortList()     //冒泡排序
    {
        Node * p = new Node();
        Node * q = new Node();
        int temp;
        for (p = pHead->pNext; p->pNext != NULL; p = p->pNext)
        {
            for (q = p->pNext; q != NULL; q = q->pNext)
            {
                if (q->data < p->data)
                {
                    temp = q->data;
                    q->data = p->data;
                    p->data = temp;
                }
            }
        }
    }

    void sortListByInsertWay()        //插入排序
    {
        if (pHead->pNext == NULL || pHead->pNext->pNext == NULL)
        {
            return;
        }
        Node * p2 = pHead->pNext->pNext;
        Node * p1 = pHead;
        pHead->pNext->pNext = NULL;
        while (p2)
        {
            Node * pN = p2->pNext;
            while (p1->pNext)
            {
                if (p2->data < p1->pNext->data)
                {
                    p2->pNext = p1->pNext;
                    p2->pLast = p1;
                    p1->pNext->pLast = p2;
                    p1->pNext = p2;
                    break;
                }
                p1 = p1->pNext;
            }
            if (p1->pNext == NULL)
            {
                p2->pNext = NULL;
                p2->pLast = p1;
                p1->pNext = p2;
            }
            p2 = pN;
        }

        //重新查找pTail的位置
        Node * pt = pHead;
        while (pt->pNext)
        {
            pt = pt->pNext;
        }
        pTail = pt;
    }

    void changeList(int num, int position)//修改鏈表中指定位置的節點
    {
        Node * p = pHead->pNext;
        if (position > length || position <= 0)
        {
            cout << "over stack !" << endl;
            return;
        }
        for (int i = 0; i < position - 1; i++)
        {
            p = p->pNext;
        }
        p->data = num;
    }

    void insertList(int num, int position)//插入數據
    {
        Node * p = pHead->pNext;
        if (position > length || position <= 0)
        {
            cout << "over stack !" << endl;
            return;
        }
        for (int i = 0; i < position - 1; i++)
        {
            p = p->pNext;
        }
        Node * temp = new Node();
        temp->data = num;
        temp->pNext = p;
        temp->pLast = p->pLast;
        p->pLast->pNext = temp;
        p->pLast = temp;
        length++;
    }

    void clearList()//清空
    {
        Node * q;
        Node * p = pHead->pNext;
        while (p != NULL)
        {
            q = p;
            p = p->pNext;
            delete q;
        }
        p = NULL;
        q = NULL;
    }

    void deleteList(int position)//刪除指定位置的節點
    {
        Node * p = pHead->pNext;
        if (position > length || position <= 0)
        {
            cout << "over stack !" << endl;
            return;
        }
        for (int i = 0; i < position - 1; i++)
        {
            p = p->pNext;
        }
        p->pLast->pNext = p->pNext;
        p->pNext->pLast = p->pLast;
        delete p;
        length--;
    }

    int getItemInList(int position)//查找指定位置的節點
    {
        Node * p = pHead->pNext;
        if (position > length || position <= 0)
        {
            cout << "over stack !" << endl;
            return 0;
        }
        for (int i = 0; i < position - 1; i++)
        {
            p = p->pNext;
        }
        return p->data;
    }

    ~List()
    {
        Node * q;
        Node * p = pHead->pNext;
        while (p != NULL)
        {
            q = p;
            p = p->pNext;
            delete q;
        }
        p = NULL;
        q = NULL;
    }

};

int main()
{
    List l(3);
    l.traverseList();
    cout << "AFTER SORT------------------------------------------------------" << endl;
    //    l.sortList();             //冒泡排序
    l.sortListByInsertWay();    //插入排序
    l.traverseList();
    cout << "AFTER INSERT-----------------------------------------------------" << endl;
    l.insertList(55, 1);
    l.traverseList();
    cout << "AFTER DELETE-----------------------------------------------------" << endl;
    l.deleteList(1);
    l.traverseList();
    cout << "Return Traverse---------------------------------------------" << endl;
    l.traverseListReturn();
    cout << "Find the Second Node's data:" << l.getItemInList(2) << endl;
    return 0;
}

轉自：https://www.cnblogs.com/flypie/p/5015711.html