双向链表的建立与相关操作

链表是数据结构中的基础知识，一般的单向链表中的节点只带有后继，没有前驱，要查找指定节点的前驱比较麻烦，而双向链表则解决这个问题。下来介绍双向链表：
首先对双向链表的节点进性定义：

/**
 *定义链表的节点
 *value为节点所存储的值
 *prev为节点的前驱地址
 *next为节点的后继
 */
class Node {
private:
    int value;
    Node *prev;
    Node *next;
public:
    Node(int initValue, Node* initPrev, Node* initNext);
    ~Node();
    int getValue();
    void setValue(int initValue);

    Node* getPrev();
    void setPrev(Node *initPrev);

    Node* getNext();
    void setNext(Node *initNext);
};

节点的操作：

/**
 *对链表节点的操作
 *初始化节点
 *清除节点内存
 *获取与设置节点的值
 *获取与设置节点前驱
 *获取与设置节点后继
 */

Node::Node(int initValue, Node* initPrev, Node* initNext) {
    this->value = initValue;
    this->prev = initPrev;
    this->next = initNext;
}
Node::~Node() {
}

int Node::getValue() {
    return this->value;
}
void Node::setValue(int initValue) {
    this->value = initValue;
}

Node* Node::getPrev() {
    return this->prev;
}
void Node::setPrev(Node* initPrev) {
    this->prev = initPrev;
}

Node* Node::getNext() {
    return this->next;
}
void Node::setNext(Node* initNext) {
    this->next = initNext;
}

对于任何数据结构都应该有增删改查的功能，对链表进性定义：

 /**
 *构建链表
 *listInsert对当前链表添加元素
 *listDelete删除指定的元素
 *listSearch查找指定的元素
 *modify改变指定元素的值
 *listShow打印链表
 *getLength获取链表长度
 *listSort采用插入排序进行排序
 */

class List {
private:
    Node *head;
    Node* getHead();
    void setHead(Node* initHead);
public:
    List();
    ~List();
    void listInsert(int key);
    void listDelete(int key);
    int listSearch(int key);
    void modify(int value, int key);
    void listShow();
    int getLength();
    void listSort();
};

链表的操作：

 *链表的操作
 */
Node* List::getHead() {
    return this->head;
}
void List::setHead(Node* initHead) {
    this->head = initHead;
}
List::List() {
    Node *initHead = new Node(INT_MIN, NULL, NULL);
    this->setHead(initHead);
}

List::~List() {
    Node *temp = (this->getHead())->getNext();
    while (temp != NULL) {
        Node *help = temp;
        temp = temp->getNext();
        delete help;
    }
}

/**
 *对链表插入元素，将元素放到该链表的尾部
 */
void List::listInsert(int key) {
    Node *nextOne = new Node(key, NULL, NULL);

    if ((this->getHead())->getNext() == NULL) {
        nextOne->setPrev(head);
        (this->getHead())->setNext(nextOne);
    }
    else {
        Node *temp = this->getHead();
        while (temp->getNext() != NULL) {
            temp = temp->getNext();
        }

        temp->setNext(nextOne);
        nextOne->setPrev(temp);
    }
}

/**
 *将链表中的指定元素删除
 */
void List::listDelete(int key) {
    Node *temp = (this->getHead())->getNext();
    while (temp != NULL) {
        if (temp->getValue() == key) {
            Node *prev = temp->getPrev();
            Node *next = temp->getNext();
            prev->setNext(next);
            next->setPrev(prev);
            delete temp;
            temp = NULL;
        }
        else {
            temp = temp->getNext();
        }
    }
    if (temp == NULL) {
        cout << key << " WAS NOT EXIT" << endl;
        return;
    }
}

/**
 *在链表中查找指定的元素
 */
int List::listSearch(int key) {
    Node *temp = (this->getHead())->getNext();
    while (temp != NULL) {
        if (temp->getValue() == key) {
            return temp->getValue();
        }
        else {
            cout << key << " WAS NOT EXIT!" << endl;
            return NULL;
        }
    }
}

/**
 *将原链表中的value的值替换为key
 */
void List::modify(int value, int key) {
    Node *temp = (this->getHead())->getNext();
    while (temp != NULL) {
        if (temp->getValue() == value) {
            temp->setValue(key);
            return;
        }
        else {
            temp = temp->getNext();
        }
    }
    if (temp == NULL) {
        cout << value << " WAS NOT EXIT!" << endl;
        return;
    }
}

/**
 *打印链表
 */
void List::listShow() {
    Node *temp = (this->getHead())->getNext();
    while (temp != NULL) {
        cout << temp->getValue() << " ";
        temp = temp->getNext();
    }
    cout << endl;
}

/**
 *获取链表的长度
 */
int List::getLength() {
    int length = 0;
    Node *temp = (this->getHead())->getNext();
    while (temp != NULL) {
        length++;
        temp = temp->getNext();
    }
    return length;
}

/**
 *使用插入排序对原链表进行排序
 */
void List::listSort() {
    if (this->getLength() == 1 || this->getLength() == 0) {
        return;
    }
    else {
        Node *temp = ((this->getHead())->getNext())->getNext();//链表的第二个元素
        //将链表中除最后一个的元素进行排序
        while (temp->getNext() != NULL) {
            Node *tempNext = temp->getNext();
            Node *tempPrev = temp->getPrev();
            Node *index = temp->getPrev();

            while (index->getValue() > temp->getValue()) {
                index = index->getPrev();
            }
            Node *indexNext = index->getNext();

            index->setNext(temp);
            temp->setPrev(index);
            tempPrev->setNext(tempNext);
            tempNext->setPrev(tempPrev);
            temp->setNext(indexNext);
            indexNext->setPrev(temp);

            temp = tempNext;
        }
        //对最后一个元素进行排序
        if (temp->getValue() < temp->getPrev()->getValue()) {

            Node *tempPrev = temp->getPrev();
            Node *index = temp->getPrev();
            while (index->getValue() > temp->getValue()) {
                index = index->getPrev();
            }
            Node *indexNext = index->getNext();
            index->setNext(temp);
            temp->setPrev(index);
            tempPrev->setNext(NULL);
            temp->setNext(indexNext);
            indexNext->setPrev(temp);
        }
    }
}

完整代码见https://github.com/GroverZhu/Data-structures-and-algorithms/tree/master/List/List

双向链表的建立与相关操作

猜你喜欢