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 = ; i < length; i++)
        {
            Node * temp = new Node();
            cout << "please enter the no" << i +  << " 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 <= )
        {
            cout << "over stack !" << endl;
            return;
        }
        for (int i = ; i < position - ; i++)
        {
            p = p->pNext;
        }
        p->data = num;
    }

    void insertList(int num, int position)//插入数据
    {
        Node * p = pHead->pNext;
        if (position > length || position <= )
        {
            cout << "over stack !" << endl;
            return;
        }
        for (int i = ; i < position - ; 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 <= )
        {
            cout << "over stack !" << endl;
            return;
        }
        for (int i = ; i < position - ; 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 <= )
        {
            cout << "over stack !" << endl;
            return ;
        }
        for (int i = ; i < position - ; 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();
    l.traverseList();
    cout << "AFTER SORT------------------------------------------------------" << endl;
    //    l.sortList();             //冒泡排序
    l.sortListByInsertWay();    //插入排序
    l.traverseList();
    cout << "AFTER INSERT-----------------------------------------------------" << endl;
    l.insertList(, );
    l.traverseList();
    cout << "AFTER DELETE-----------------------------------------------------" << endl;
    l.deleteList();
    l.traverseList();
    cout << "Return Traverse---------------------------------------------" << endl;
    l.traverseListReturn();
    cout << "Find the Second Node's data:" << l.getItemInList() << endl;
    return ;
}

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