《数据结构与算法分析：C语言描述》复习——第三章“线性表、栈和队列”——双向链表

2014.06.14 20:17

简介：

　　双向链表是LRU Cache中要用到的基本结构，每个链表节点左右分别指向上一个和下一个节点，能够自由地左右遍历。

图示：

　　

实现：

 // My implementation for doubly linked list.
 struct ListNode {
     int val;
     ListNode *prev;
     ListNode *next;
     ListNode(int _val = ): val(_val), next(nullptr), prev(nullptr) {};
 };

 class DoublyLinkedList {
 public:
     DoublyLinkedList() {
         m_size = ;
         m_head = nullptr;
         m_tail = nullptr;
     }

     void insertFront(int val) {
         if (m_size == ) {
             m_head = m_tail = new ListNode(val);
         } else {
             ListNode *ptr = new ListNode(val);
             ptr->next = m_head;
             m_head->prev = ptr;
             m_head = ptr;
         }
         ++m_size;
     }

     void insertBack(int val) {
         if (m_size == ) {
             m_head = m_tail = new ListNode(val);
         } else {
             m_tail->next = new ListNode(val);
             m_tail->next->prev = m_tail;
             m_tail = m_tail->next;
         }
         ++m_size;
     }

     void insertNode(int pos, int val) {
         int i;

         if (i <= ) {
             insertFront(val);
         } else if (i >= m_size) {
             insertBack(val);
         } else {
             ListNode *ptr1, *ptr2;

             ptr1 = m_head;
             for (i = ; i < pos - ; ++i) {
                 ptr1 = ptr1->next;
             }
             ptr2 = new ListNode(val);
             ptr2->next = ptr1->next;
             ptr1->next->prev = ptr2;
             ptr1->next = ptr2;
             ptr2->prev = ptr1;
             ++m_size;
         }
     }

     void deleteNode(int pos) {
         if (pos <  || pos > m_size - ) {
             return;
         }

         ListNode *ptr1, *ptr2;
         if (pos == ) {
             ptr1 = m_head;
             if (m_size == ) {
                 m_head = m_tail = nullptr;
             } else {
                 m_head = m_head->next;
                 m_head->prev = nullptr;
             }
             delete ptr1;
         } else {
             ptr1 = m_head;
             for (int i = ; i < pos - ; ++i) {
                 ptr1 = ptr1->next;
             }
             ptr2 = ptr1->next;
             ptr1->next = ptr2->next;
             if (ptr2->next == nullptr) {
                 m_tail = ptr1;
             } else {
                 ptr2->next->prev = ptr1;
             }
             delete ptr2;
         }
         --m_size;
     }

     void updateNode(int pos, int val) {
         if (pos <  || pos > m_size - ) {
             return;
         }

         ListNode *ptr = m_head;
         for (int i = ; i < pos; ++i) {
             ptr = ptr->next;
         }
         ptr->val = val;
     }

     ListNode *findNode(int val) {
         ListNode *ptr = m_head;
         while (ptr != nullptr) {
             if (ptr->val == val) {
                 return ptr;
             }
             ptr = ptr->next;
         }

         return nullptr;
     }

     ~DoublyLinkedList() {
         ListNode *ptr = m_head;
         while (m_head != nullptr) {
             m_head = m_head->next;
             delete ptr;
             ptr = m_head;
         }
         m_head = m_tail = nullptr;
     }
 private:
     int m_size;
     ListNode *m_head;
     ListNode *m_tail;
 };

 int main()
 {
     return ;
 }