【C++】模板實現帶頭節點的雙向迴圈連結串列
阿新 • • 發佈：2019-02-14
連結串列分為帶頭節點和不帶頭節點，單鏈表和雙向迴圈連結串列。
帶頭節點的連結串列雖然有頭結點，但是並不儲存資料，雙向迴圈鏈有指向前一個數的指標和指向後一個數的指標。
如下圖：
先來實現一些主要的函式：
List的建構函式和解構函式：
List()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
~List()
{
clear();
delete _head;
_head = NULL;
}List在任意一個位置插入一個數和刪除一個數
//任意一個位置插入一個數,在pos的前面插入一個數據 void Insert(Node* pos, const T& x) { assert(pos); Node* tmp = new Node(x); Node* cur = pos; Node* prev = cur->_prev; prev->_next = tmp; tmp->_prev = prev; tmp->_next = cur; cur->_prev = tmp; } //刪除任意一個位置的數 void Erase(Node* pos) { assert(pos && pos != _head); Node* prev = pos->_prev; Node* next = pos->_next; prev->_next = next; next->_prev = prev; delete pos; }
有了插入和刪除函式之後，其他的函式都可以用Erase和Insert來複用：
尾部插入和刪除函式：
//尾部插入一個數
void PushBack(const T& x)
{
Insert(_head, x);
}
//尾部刪除一個數
void PopBack(const T& x)
{
Erase(_head->_prev);
}頭部插入和刪除資料：
//頭部插入一個數 void PushFront(const T& x) { Insert(_head->_next,x); } //頭部刪除一個數 void PopFront(const T& x) { Erase(_head->_next); }
建構函式和賦值運算子過載：
//拷貝建構函式 List(const List<T> & l) { _head = new Node(); _head->_next = _head; _head->_prev = _head; Node* cur = (l._head)->_next; while (cur != l._head) { this->PushBack(cur->_data); cur = cur->_next; } } //賦值運算子過載 List<T>& operator=(const List<T>& l) { if (this != &l) { this->clear(); Node* cur = l._head->_next; while (cur != l._head) { this->PushBack(cur->_data); cur = cur->_next; } } return *this; }
在插入和刪除資料的時候要考慮雙向連結串列裡面會出現的各種情況！
以下是完整的程式碼：
ListNode.h
#pragma once
#include<assert.h>
template<class T>
struct ListNode
{
T _data;
ListNode<T>* _next;
ListNode<T>* _prev;
ListNode(const T& x = T())
:_data(x)
, _next(NULL)
, _prev(NULL)
{}
};
template<class T>
class List
{
typedef ListNode<T> Node;
public:
List()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
~List()
{
clear();
delete _head;
_head = NULL;
}
//刪除任意一個位置的數
void Erase(Node* pos)
{
assert(pos && pos != _head);
Node* prev = pos->_prev;
Node* next = pos->_next;
prev->_next = next;
next->_prev = prev;
delete pos;
}
//任意一個位置插入一個數,在pos的前面插入一個數據
void Insert(Node* pos, const T& x)
{
assert(pos);
Node* tmp = new Node(x);
Node* cur = pos;
Node* prev = cur->_prev;
prev->_next = tmp;
tmp->_prev = prev;
tmp->_next = cur;
cur->_prev = tmp;
}
//尾部插入一個數
void PushBack(const T& x)
{
Insert(_head, x);
}
//尾部刪除一個數
void PopBack(const T& x)
{
Erase(_head->_prev);
}
//頭部插入一個數
void PushFront(const T& x)
{
Insert(_head->_next,x);
}
//頭部刪除一個數
void PopFront(const T& x)
{
Erase(_head->_next);
}
//查詢一個數
void Find(const T& x)
{
Node* cur = _head->_next;
while (cur != _head)
{
if (cur->_data == x)
{
return cur;
}
return NULL;
}
}
//清除
void clear()
{
Node* cur = _head->_next;
while (cur != _head)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
_head->_next = _head;
_head->_prev = _head;
}
//列印
void Print()
{
Node* cur = _head->_next;
while (cur!=_head)
{
cout << cur->_data << "";
cur = cur->_next;
}
cout << endl;
}
//拷貝建構函式
List(const List<T> & l)
{
_head = new Node();
_head->_next = _head;
_head->_prev = _head;
Node* cur = (l._head)->_next;
while (cur != l._head)
{
this->PushBack(cur->_data);
cur = cur->_next;
}
}
//賦值運算子過載
List<T>& operator=(const List<T>& l)
{
if (this != &l)
{
this->clear();
Node* cur = l._head->_next;
while (cur != l._head)
{
this->PushBack(cur->_data);
cur = cur->_next;
}
}
return *this;
}
protected:
Node* _head;
};
void Test1()//尾部插入和刪除
{
//插入
List<int> l;
l.PushBack(1);
l.Print();
l.PushBack(2);
l.Print();
l.PushBack(3);
l.Print();
l.PushBack(4);
l.Print();
//刪除
l.PopBack(1);
l.Print();
l.PopBack(1);
l.Print();
l.PopBack(1);
l.Print();
}
void Test2()//頭部插入和刪除
{
//插入
List<int> l;
l.PushFront(1);
l.Print();
l.PushFront(2);
l.Print();
l.PushFront(3);
l.Print();
//刪除
l.PopFront(1);
l.Print();
l.PopFront(1);
l.Print();
l.PopFront(1);
l.Print();
}
測試函式
Test.cpp
#include<iostream>
using namespace std;
#include"ListNode.h"
int main()
{
Test1();
Test2();
system("pause");
return 0;
}