雙鏈表

雙鏈表的意義

單鏈表相對於順序表，確實在某些場景下解決了一些重要的問題，例如在需要插入或者刪除大量元素的時候，它並不需要像順序表一樣移動很多元素，只需要修改指標的指向就可以了，其時間複雜度為 O(1) 但是這可是有前提的，那就是這一切都基於確定節點後，純粹考慮刪除和插入的情況下，但是如果我們仍未確定節點的位置，那麼單鏈表就會出現一些問題了，例如我們來看一下刪除這個操作

刪除操作

單鏈表:

對應圖中的節點，想要刪除第2個節點 a1 只需要 將首元結點的指標指向到第三個節點的地址去

但是問題就在於我們如何得到待刪除節點的前驅，也就是我們圖中的首元結點，我們給出兩種方法

• A：定位待刪除節點的同時，一直順便儲存當前節點的前驅
• B：刪除節點後，重新回到單鏈表表頭，定位到其指定前驅

但是無論我們選擇哪一種方法，指標的總移動數都會是 2n 次，而雙鏈表卻在這一型別問題上做出了很好的處理

雙鏈表:

單鏈表中之所以出現問題，就是因為各個節點只有一個指向後繼的指標域 next，只能向後移動查詢，一旦我們想要查詢前一節點，就變得很麻煩，所以雙鏈表就在每個節點前面增加一個指向前驅的指標域 prior，這樣我們就可以直接定位到我們的前一個節點了，這也就是雙鏈表

注意：為了統一運算，避免特殊情況的出現，我們也常常在尾部設定一個 “尾部頭結點” 其 next 指標域為空

線性表的抽象資料型別定義

我們在給出雙鏈表的定義之前我們還是需要先引入我們線性表的抽象資料型別定義

#ifndef _LIST_H_
#define _LIST_H_
#include<iostream>
using namespace std;

class outOfRange{};
class badSize{};
template<class T>
class List {
public:
    // 清空線性表
	virtual void clear()=0;
    // 判空，表空返回true，非空返回false
	virtual bool empty()const=0;
    // 求線性表的長度
	virtual int size()const=0;
    // 線上性表中，位序為i[0..n]的位置插入元素value
	virtual void insert(int i,const T &value)=0;
    // 線上性表中，位序為i[0..n-1]的位置刪除元素
	virtual void remove(int i)=0;
    // 線上性表中，查詢值為value的元素第一次出現的位序
	virtual int search(const T&value)const=0;
    // 線上性表中，查詢位序為i的元素並返回其值
	virtual T visit(int i)const=0;
    // 遍歷線性表
	virtual void traverse()const=0;
    // 逆置線性表
	virtual void inverse()=0;					
	virtual ~List(){};
};

/*自定義異常處理類*/ 


class outOfRange :public exception {  //用於檢查範圍的有效性
public:
	const char* what() const throw() {
		return "ERROR! OUT OF RANGE.\n";
	}
};

class badSize :public exception {   //用於檢查長度的有效性
public:
	const char* what() const throw() {
		return "ERROR! BAD SIZE.\n";
	}
};

#endif
 

雙鏈表型別的定義

#ifndef _SEQLIST_H_
#define _SEQLIST_H_
#include "List.h"
#include<iostream>
using namespace std;

template<class elemType>
//elemType為雙鏈表儲存元素型別 
class doubleLinkList:public List<elemType> {
private:
	//節點型別定義 
	struct Node {
		//節點的資料域 
		elemType data;
		//節點的兩個指標域 
		Node *prior, *next;
		//兩個建構函式 
		Node(const elemType &value, Node *p = NULL, Node *n = NULL) {
			data = value;
			prior = p;
			next = n;
		}
		 
		Node():next(NULL), prior(NULL) {}
		~Node(){} 
	};
	
	//單鏈表的頭指標 
	Node *head;
	//單鏈表的尾指標 
	Node *tail;
	//單鏈表的當前長度 
	int curLength;
	//返回指向位序為i的節點的指標 
	Node *getPosition(int i)const; 
	
public:
	doubleLinkList();
	~doubleLinkList();
	//清空單鏈表，使其成為空表 
	void clear();
	//帶頭結點的單鏈表，判空 
	bool empty()const {return head -> next == NULL;} 
	//返回單鏈表的當前實際長度
	int size()const {return curLength;}
	//在位序i處插入值為value的節點表長增1 
	void insert(int i, const elemType &value); 
	//刪除位序為i的節點的值，表長減1 
	void remove(int i);
	//查詢值為value的節點的第一次出現的位置 
	int search(const elemType &value)const;
	//查詢值為value的節點的前驅的位序
	int prior(const elemType&value)const;
	//訪問位序為i的節點的值，0定位到首元結點
	elemType visit(int i)const;
	//遍歷單鏈表
	void traverse()const;
	//逆置單鏈表 
	void inverse();
	//合併單鏈表 
};

雙鏈表基本運算的實現

(一) 構造與解構函式

template <class elemType>
doubleLinkList<elemType>::doubleLinkList() {
	//頭尾節點分別指向 頭結點和尾部頭結點 
	head = new Node;
	tail = new Node;
	head -> next = tail;
	tail -> prior = head;
} 

template <class elemType>
doubleLinkList<elemType>::~doubleLinkList() {
	Node *p = head -> next, *tmp;
	//頭結點的後繼是尾部頭結點 
	head -> next = tail;
	//尾部頭結點的前驅是頭結點 
	tail -> prior = tail;
	
	while(p != tail) {
		tmp = p -> next;
		delete p;
		p = tmp;
	} 
	curLength = 0;	
}

(二) 查詢位序為i的節點的地址

template <class elemType>
typename doubleLinkList<elemType>::Node *doubleLinkList<elemType>::getPosition(int i) const {
	Node *p = head;
	int count = 0;
	if(i < -1 || i > curLength) 
		return NULL;
	while(count <= -1) {
		p = p -> next;
		count++;
	}
	return p;
}

(三) 查詢值為value的節點的位序

template <class elemType>
int doubleLinkList<elemType>::search(const elemType &value) const {
	Node *p = head -> next;
	int i = 0;
	while(p != tail && p -> data != value) {
		p = p -> next;
		i++;
	}
	if(p == tail)
		return -1;
	else 
		return i;
} 

(四) 插入元素

template <class elemType>
void doubleLinkList<elemType>::insert(int i, const elemType &value) {
	Node *p, * tmp;
	if(i < 0 || i > curLength)
		throw outOfRange();
	p = getPosition(i);
	tmp = new Node(value, p -> prior, p);
	//p原先的前驅的後繼指向tmp 
	p -> prior -> next = tmp;
	//修改p的前驅為tmp
	p -> prior = tmp;
	++curLength;
} 

(五) 刪除位序為i的節點

template <class elemType>
void doubleLinkList<elemType>::remove(int i) {
	Node *p;
	if(i < 0 || i > curLength)
		throw outOfRange();
	p = getPosition(i);
	p -> prior -> next = p -> next;
	p -> next -> prior = p -> prior;
	delete p;
	--curLength;
} 

(六) 訪問位序為 i的節點的值

template <class elemType>
elemType doubleLinkList<elemType>::visit(int i) const {
	//visit 不嫩直接用getPosition判斷範圍是否合法，因為其範圍為[-1,curLength]
	if(i < 0 || i > curLength -1)
		throw outOfRange();
	//合法以後 
	Node *p = getPosition(i);
	return p -> data; 
}

(七) 遍歷雙鏈表

template <class elemType>
void doubleLinkList<elemType>::traverse() const {
	Node *p = head -> next;
	cout << "traverse: ";
	while(p != tail) {
		cout << p -> data << " ";
		p = p -> next;
	}
	cout << endl;
}   

(八) 遍歷雙鏈表

template <class elemType>
void doubleLinkList<elemType>::inverse() {
	Node *tmp, *p = head -> next;
	//構成雙空連結串列 
	head -> next = tail;
	tail -> prior = head;
	while(p != tail) {
		tmp = p -> next;
		p -> next = head -> next;
		p -> prior = head;
		head -> next -> prior = p;
		head -> next = p;
		p = tmp;
	} 
} 

結尾：

如果文章中有什麼不足，或者錯誤的地方，歡迎大家留言分享想法，感謝朋友們的支援！

如果能幫到你的話，那就來關注我吧！如果您更喜歡微信文章的閱讀方式，可以關注我的公眾號

在這裡的我們素不相識，卻都在為了自己的夢而努力 ❤

一個堅持推送原創開發技術文章的公眾號：理想二旬不止

相關推薦