数据结构(C++)之Double Linked List实践

 //double linked list (type int),the position starts from 0
 #include <iostream>
 using namespace std;

 //Class Node
 class Node
 {
 public:
     Node();
     Node(int val);
     ~Node();

     void setVal(int val);
     int getVal();

     Node* prior;   //指向前节点指针
     Node* next;   //指向后节点指针

 private:
     int val = ;
 };

 Node::Node()
 {
 }

 Node::Node(int val)
 {
     this->val = val;
     prior = next = nullptr;
 }

 Node::~Node()
 {
 }

 void Node::setVal(int val)
 {
     this->val = val;
 }

 int Node::getVal()
 {
     return this->val;
 }

 //Class DoubleLinkedList
 class DLlist
 {
 public:

     DLlist(int size);
     ~DLlist();

     int getSize();

     void insert(int num, int pos);   //在两节点间插入，插入位置的前后节点必须都存在

     void deleteList(int pos);   //删除节点，删除位置的前后节点必须都存在

     void addFirst(int element);     //pushFront

     void addLast(int element);   //pushBack

     int removeFirst();

     int removeLast();

     int returnNth(int pos);

     bool isEmpty();

     void printList();

     void Clear();

 private:
     int size = ;
     Node* head;  //指向头节点的指针
     Node* tail;     //指向尾节点的指针

     Node* GetPointer(int pos);   //查找节点

 };

 DLlist::DLlist(int size)
 {
     this->size = size;
     head = new Node;
     head->prior = nullptr;
     head->next = nullptr;
     tail = head;
     for (int i = ; i < this->size; i++)
     {
         int v;
         cout << "Enter the value of No. " << i +  << " Node: ";
         cin >> v;
         if (i == )
         {
             head->setVal(v);
         }
         else
         {
             Node* temp = new Node;
             temp->setVal(v);
             temp->next = nullptr;
             temp->prior = tail;
             tail->next = temp;
             tail = temp;
         }
     }
 }

 DLlist::~DLlist()
 {
     Clear();
 }

 int DLlist::getSize()
 {
     return this->size;
 }

 void DLlist::insert(int num, int pos)
 {
     Node* temp = new Node;
     Node* position;
     temp->setVal(num);
     position = GetPointer(pos);
     (position->prior)->next = temp;
     temp->next = position;
     temp->prior = position->prior;
     position->prior = temp;
     size++;
 }

 void DLlist::deleteList(int pos)
 {
     Node* position;
     position = GetPointer(pos);
     (position->prior)->next = position->next;
     (position->next)->prior = position->prior;
     delete position;
     size--;
 }

 void DLlist::addFirst(int element)
 {
     if (head == nullptr)
     {
         head->setVal(element);
         head->prior = nullptr;
         head->next = nullptr;
         tail = head;
         size++;
     }
     else
     {
         /*我们要在头结点前再插入一个结点，需要先创建一个新的结点，将头结点的值保存在新节点，然后让新节点的下
         个结点指向头结点的下一个结点，再让新节点的prior指向头结点，这样就将新节点与原来的链表融合了，然后我
         们将头结点的数据换成element即可*/

         Node* temp = new Node;
         temp->setVal(head->getVal());
         temp->next = head->next;
         temp->prior = head;
         if (size > )
         {
             (head->next)->prior = temp;
         }
         head->next = temp;
         head->setVal(element);
         size++;
     }
 }

 void DLlist::addLast(int element)
 {
     if (head == nullptr)
     {
         head->setVal(element);
         head->prior = nullptr;
         head->next = nullptr;
         tail = head;
         size++;
     }
     else
     {
         Node* temp = new Node;
         temp->setVal(tail->getVal());
         temp->prior = tail->prior;
         temp->next = tail;
         if (size -  != )
         {
             (tail->prior)->next = temp;
         }
         tail->prior = temp;
         tail->setVal(element);
         size++;
     }
 }

 int DLlist::removeFirst()
 {
     int v = head->getVal();

     head = head->next;
     if (size > )
     {
         head->prior = nullptr;
     }

     size--;
     return v;
 }

 int DLlist::removeLast()
 {
     int v = tail->getVal();

     tail = tail->prior;
     if (size>)
     {
         tail->next = nullptr;
     }

     size--;
     return v;
 }

 int DLlist::returnNth(int pos)
 {
     return GetPointer(pos)->getVal();
 }

 bool DLlist::isEmpty()
 {
     if (size == )
     {
         return true;
     }
     else
     {
         return false;
     }
 }

 void DLlist::printList()
 {
     for (int i = ; i < size; i++)
     {
         cout << "No. " << i +  << " = " << GetPointer(i)->getVal() << endl;
     }
 }

 void DLlist::Clear()
 {
     while (head != nullptr)
     {
         Node * temp = head->next;
         delete head;
         head = temp;
     }
     tail = nullptr;
     size = ;
 }

 Node* DLlist::GetPointer(int pos)
 {
     Node* pNode = nullptr;
     if (pos< || pos>size - )
     {
         cout << "Out of range! " << endl;
         return nullptr;
     }
     else
     {
         pNode = head;
         for (int i = ; i < pos; i++)
         {
             pNode = pNode->next;
         }
         return pNode;
     }
 }

 int main()
 {
     DLlist d();
     cout << endl;
     cout << "Size: " << d.getSize() << endl;
     d.printList();
     cout << endl;

     cout << "Insert 10 at position 1" << endl;
     d.insert(, );
     cout << "Size: " << d.getSize() << endl;
     d.printList();

     cout << endl;
     cout << "Addfirst 100" << endl;
     d.addFirst();
     cout << "Now No.1's value= " << d.returnNth() << endl;
     d.printList();

     cout << endl;
     cout << "Remove last" << endl;
     d.removeLast();
     d.printList();

     cout << endl;
     cout << "Remove first" << endl;
     d.removeFirst();
     d.printList();

     cout << endl;
     d.Clear();
     cout << "Use Clear()" << endl;
     cout << "isEmpty: " << boolalpha << d.isEmpty() << endl;

     system("pause");
     return ;
 }

---

取消int类型，加入模板

 //double linked list ,the position starts from 0
 #include <iostream>
 #include <iomanip>
 using namespace std;

 //Class Node
 template <typename T>
 class Node
 {
 public:
     Node();
     Node(T val);
     ~Node();

     void setVal(T val);
     T getVal();

     Node* prior;   //指向前节点指针
     Node* next;   //指向后节点指针

 private:
     T val ;
 };

 template<typename T>
 Node<T>::Node()
 {
     this->val = T();
 }

 template<typename T>
 Node<T>::Node(T val)
 {
     this->val = val;
     prior = next = nullptr;
 }

 template<typename T>
 Node<T>::~Node()
 {
 }

 template<typename T>
 void Node<T>::setVal(T val)
 {
     this->val = val;
 }

 template<typename T>
 T Node<T>::getVal()
 {
     return this->val;
 }

 //Class DoubleLinkedList
 template<typename T>
 class DLlist
 {
 public:

     DLlist(int size);
     ~DLlist();

     int getSize();

     void insert(T num, int pos);   //在两节点间插入，插入位置的前后节点必须都存在

     void deleteList(int pos);   //删除节点，删除位置的前后节点必须都存在

     void addFirst(T element);     //pushFront

     void addLast(T element);   //pushBack

     T removeFirst();

     T removeLast();

     T returnNth(int pos);

     bool isEmpty();

     void printList();

     void Clear();

 private:
     int size = ;
     Node<T>* head;  //指向头节点的指针
     Node<T>* tail;     //指向尾节点的指针

     Node<T>* GetPointer(int pos);   //查找节点

 };

 template<typename T>
 DLlist<T>::DLlist(int size)
 {
     this->size = size;
     head = new Node<T>;
     head->prior = nullptr;
     head->next = nullptr;
     tail = head;
     for (int i = ; i < this->size; i++)
     {
         T v;
         cout << "Enter the value of No. " << i +  << " Node: ";
         cin >> v;
         if (i == )
         {
             head->setVal(v);
         }
         else
         {
             Node<T>* temp = new Node<T>;
             temp->setVal(v);
             temp->next = nullptr;
             temp->prior = tail;
             tail->next = temp;
             tail = temp;
         }
     }
 }

 template<typename T>
 DLlist<T>::~DLlist()
 {
     Clear();
 }

 template<typename T>
 int DLlist<T>::getSize()
 {
     return this->size;
 }

 template<typename T>
 void DLlist<T>::insert(T num, int pos)
 {
     Node<T>* temp = new Node<T>;
     Node<T>* position;
     temp->setVal(num);
     position = GetPointer(pos);
     (position->prior)->next = temp;
     temp->next = position;
     temp->prior = position->prior;
     position->prior = temp;
     size++;
 }

 template<typename T>
 void DLlist<T>::deleteList(int pos)
 {
     Node<T>* position;
     position = GetPointer(pos);
     (position->prior)->next = position->next;
     (position->next)->prior = position->prior;
     delete position;
     size--;
 }

 template<typename T>
 void DLlist<T>::addFirst(T element)
 {
     if (head == nullptr)
     {
         head->setVal(element);
         head->prior = nullptr;
         head->next = nullptr;
         tail = head;
         size++;
     }
     else
     {
         /*我们要在头结点前再插入一个结点，需要先创建一个新的结点，将头结点的值保存在新节点，然后让新节点的下
         个结点指向头结点的下一个结点，再让新节点的prior指向头结点，这样就将新节点与原来的链表融合了，然后我
         们将头结点的数据换成element即可*/

         Node<T>* temp = new Node<T>;
         temp->setVal(head->getVal());
         temp->next = head->next;
         temp->prior = head;
         if (size > )
         {
             (head->next)->prior = temp;
         }
         head->next = temp;
         head->setVal(element);
         size++;
     }
 }

 template<typename T>
 void DLlist<T>::addLast(T element)
 {
     if (head == nullptr)
     {
         head->setVal(element);
         head->prior = nullptr;
         head->next = nullptr;
         tail = head;
         size++;
     }
     else
     {
         Node<T>* temp = new Node<T>;
         temp->setVal(tail->getVal());
         temp->prior = tail->prior;
         temp->next = tail;
         if (size -  != )
         {
             (tail->prior)->next = temp;
         }
         tail->prior = temp;
         tail->setVal(element);
         size++;
     }
 }

 template<typename T>
 T DLlist<T>::removeFirst()
 {
     T v = head->getVal();

     head = head->next;
     if (size > )
     {
         head->prior = nullptr;
     }

     size--;
     return v;
 }

 template<typename T>
 T DLlist<T>::removeLast()
 {
     T v = tail->getVal();

     tail = tail->prior;
     if (size>)
     {
         tail->next = nullptr;
     }

     size--;
     return v;
 }

 template<typename T>
 T DLlist<T>::returnNth(int pos)
 {
     return GetPointer(pos)->getVal();
 }

 template<typename T>
 bool DLlist<T>::isEmpty()
 {
     if (size == )
     {
         return true;
     }
     else
     {
         return false;
     }
 }

 template<typename T>
 void DLlist<T>::printList()
 {
     for (int i = ; i < size; i++)
     {
         cout << "No. " << i +  << " = " <<setiosflags(ios::fixed)<<setprecision()<<GetPointer(i)->getVal() << endl;
     }
 }

 template<typename T>
 void DLlist<T>::Clear()
 {
     while (head != nullptr)
     {
         Node<T>* temp = head->next;
         delete head;
         head = temp;
     }
     tail = nullptr;
     size = ;
 }

 template<typename T>
 Node<T>* DLlist<T>::GetPointer(int pos)
 {
     Node<T>* pNode = nullptr;
     if (pos< || pos>size - )
     {
         cout << "Out of range! " << endl;
         return nullptr;
     }
     else
     {
         pNode = head;
         for (int i = ; i < pos; i++)
         {
             pNode = pNode->next;
         }
         return pNode;
     }
 }

 int main()
 {
     DLlist<double> d();
     cout << endl;
     cout << "Size: " << d.getSize() << endl;
     d.printList();
     cout << endl;

     cout << "Insert 10.0 at position 1" << endl;
     d.insert(10.0, );
     cout << "Size: " << d.getSize() << endl;
     d.printList();

     cout << endl;
     cout << "Addfirst 100.0" << endl;
     d.addFirst(100.0);
     cout << "Now No.1's value= " << d.returnNth() << endl;
     d.printList();

     cout << endl;
     cout << "Remove last" << endl;
     d.removeLast();
     d.printList();

     cout << endl;
     cout << "Remove first" << endl;
     d.removeFirst();
     d.printList();

     cout << endl;
     d.Clear();
     cout << "Use Clear()" << endl;
     cout << "isEmpty: " << boolalpha << d.isEmpty() << endl;

     system("pause");
     return ;
 }