双向链表

双向链表的操作与单链表的基本相似

typedef struct DoublyListNode
{
    int data;
    DoublyListNode *prev;
    DoublyListNode *next;
}Node;


class DoublyList
{
public:
    DoublyList();
    ~DoublyList();
    void CreateNodeF(int len, int *arr)const;
    void CreateNodeE(int len, int *arr)const;
    bool Insert(int index, int num) const;
    bool DelNode(int index);
    void DispList()const;

    void Reverse()const;
    void Sort()const;
private:
    Node *m_head;
};

#include "DoublyList.h"
#include <iostream>


DoublyList::DoublyList()
{
    m_head = new Node;
    m_head->next = nullptr;
    m_head->prev = nullptr;
}


DoublyList::~DoublyList()
{
    while (m_head)
    {
        Node *tmp = m_head;
        m_head = m_head->next;
        delete tmp;
    }
}

void DoublyList::CreateNodeF(int len, int *arr) const
{

    for (int i = 0; i < len; ++i)
    {
        Node *newNode = new Node;
        newNode->data = arr[i];
        newNode->next = m_head->next;
        if (m_head->next)
        {
            m_head->next->prev = newNode;
        }
        m_head->next = newNode;
        newNode->prev = m_head;
    }
}

void DoublyList::CreateNodeE(int len, int* arr) const
{
    Node *tmp = m_head;
    for (int i = 0; i < len; ++i)
    {
        Node *newNode = new Node;
        newNode->data = arr[i];
        newNode->next = m_head->next;

        tmp->next = newNode;
        newNode->prev = tmp;
        tmp = newNode;
    }
    tmp->next = nullptr;
}

bool DoublyList::Insert(int index, int num) const
{
    bool ret = false;
    Node *tmp = m_head;
    int i = 0;
    while (i < index -1 && tmp)
    {
        ++i;
        tmp = tmp->next;
    }

    if(tmp)
    {
        Node *newNode = new Node;
        newNode->data = num;
        newNode->next = tmp->next;
        if(tmp->next)
        {
            tmp->next->prev = newNode;
        }
        newNode->prev = tmp;
        tmp->next = newNode;
        ret = true;
    }

    return ret;
}

bool DoublyList::DelNode(int index)
{
    bool ret = false;

    Node *tmp = m_head;
    int i = 0;
    while (i < index -1 && tmp)
    {
        ++i;
        tmp = tmp->next;
    }

    if(tmp)
    {
        Node *nextNode = tmp->next;
        if(nextNode)
        {
            tmp->next = nextNode->next;
            if (tmp->next)
                tmp->next->prev = tmp;

            delete nextNode;
            ret = true;
        }
    }

    return ret;
}

void DoublyList::DispList() const
{
    Node *tmp = m_head->next;

    while (tmp)
    {
        std::cout << tmp->data << " ";
        tmp = tmp->next;
    }
    std::cout << std::endl;
}

void DoublyList::Reverse() const
{
    Node *tmp = m_head->next;
    m_head->next = nullptr;

    while (tmp) 
    {
        Node *nextNode = tmp->next;
        tmp->next = m_head->next;
        if (m_head->next)
            m_head->next->prev = tmp;

        m_head->next = tmp;
        tmp->prev = m_head;
        tmp = nextNode;
    }
}

void DoublyList::Sort() const
{
    Node *tmp = m_head->next->next;
    m_head->next->next = nullptr;

    while (tmp)
    {
        Node *nextNode = tmp->next;
        Node *prev = m_head;

        while (prev->next && prev->next->data < tmp->data)
        {
            prev = prev->next;
        }
        tmp->next = prev->next;
        if (prev->next)
            prev->next->prev = tmp;

        prev->next = tmp;
        tmp->prev = prev;
        tmp = nextNode;

    }
}