2. 程式人生 > >資料結構實現 2.1：連結串列（C++版）

資料結構實現 2.1：連結串列（C++版）

阿新 • • 發佈：2018-12-20

1. 概念及基本框架

連結串列 是一種 線性結構 ，而且儲存上屬於 鏈式儲存（即記憶體的物理空間是不連續的），是線性表的一種。連結串列結構如下圖所示：
連結串列
下面以一個我實現的一個簡單的連結串列類來進一步理解連結串列。

template <class T>
class Node{
public:
	Node(T num = NULL, Node *next = NULL){
		m_data = num;
		this->next = next;
	}
public:
	T m_data;
	Node *next;
};

首先設計一個 結點類 ，這個結點類包含 資料 和 指向下一個結點的指標

。結點類的建構函式可以直接對結點賦值，然後利用結點類物件來建立一個連結串列。連結串列類的設計如下：

template <class T>
class LinkedList{
public:
	LinkedList(){
		head.m_data = NULL;
		head.next = NULL;
		m_size = 0;
	}
	...
private:
	Node<T> head;
	int m_size;
};

這裡為了避免重複設計就可以相容更多資料型別，引入了 泛型 ，即 模板 的概念。（模板的關鍵字是 class 或 typename）
這裡的 m_size

表示 連結串列長度 。為了保護資料，這個變數以及 結點資料 都設定為 private 。
與動態陣列不同，動態陣列的“動態”含義是可以自動擴容（縮容），但實質還是靜態的，而連結串列則實現了真正意義上的動態。因為只有需要一個結點，才會新增一個結點，不需要就會刪除。在這裡，為了下面程式程式碼編寫方便、統一，引入了 虛擬頭結點（也稱 哨兵結點 ）的概念。這個結點本身不存放資料，使用者也不知道它的存在。
實現了前面的程式之後，接下來就是一個連結串列的增、刪、改、查以及一些其他基本操作，接下來利用程式碼去實現。

2. 基本操作程式實現

2.1 增加操作

template <class T>
 

class LinkedList{
public:
	...
	//增加操作
	void add(int index, T num);
	void addFirst(T num);
	void addLast(T num);
	...
};

首先，在類體內進行增加操作函式的原型說明。這裡包括三個函式：
add（新增到任意位置）
addFirst（新增到頭部）
addLast（新增到尾部）
然後分別去實現它們。

template <class T>
void LinkedList<T>::add(int index, T num){
	if (index < 0 || index > m_size){
		cout << "新增位置非法！" << endl;
		return;
	}
	Node<T> *node = &head;
	for (int i = 0; i < index; ++i, node = node->next);
	node->next = new Node<T>(num, node->next);
	m_size++;
}
template <class T>
void LinkedList<T>::addFirst(T num){
	add(0, num);
}
template <class T>
void LinkedList<T>::addLast(T num){
	add(m_size, num);
}

由於這些函式在類體外，所以每個函式頭部必須新增一行程式碼：

template <class T>

表示該函式使用模板，下面同理。
如果不使用虛擬頭結點，程式碼編寫就要區分第一個結點和其他結點，從這裡可以看出引入虛擬頭結點的好處，統一了程式碼編寫形式，下面的同理。

2.2 刪除操作

template <class T>
class LinkedList{
public:
	...
	//刪除操作
	T remove(int index);
	T removeFirst();
	T removeLast();
	void removeElement(T num);
	...
};

同理，在類體內進行刪除函式的原型說明。這裡包括四個函式：
remove（刪除任意位置元素）：返回刪除元素的值。
removeFirst（刪除頭部元素）：返回刪除元素的值。
removeLast（刪除尾部元素）：返回刪除元素的值。
removeElement（刪除特定元素）：這裡刪除的是第一個這樣的元素，如果想把這樣的元素都刪掉，可以寫一個新的函式來實現。
然後分別去實現它們。

template <class T>
T LinkedList<T>::remove(int index){
	if (index < 0 || index >= m_size){
		cout << "刪除位置非法！" << endl;
		return NULL;
	}
	Node<T> *node = &head;
	for (int i = 0; i < index; ++i, node = node->next);
	Node<T> *p = node->next;
	T res = p->m_data;
	node->next = p->next;
	delete p;
	m_size--;
	return res;
}
template <class T>
T LinkedList<T>::removeFirst(){
	return remove(0);
}
template <class T>
T LinkedList<T>::removeLast(){
	return remove(m_size - 1);
}
template <class T>
void LinkedList<T>::removeElement(T num){
	if (!head.next){
		return;
	}
	Node<T> *node = &head;
	Node<T> *p;
	while(node){
		p = node->next;
		if (p->m_data == num){
			node->next = p->next;
			delete p;
			m_size--;
			return;
		}
		node = p;
	}
}

這裡刪除操作的“刪除位置非法”後面返回的 NULL 也可以用 throw 拋異常來實現，這裡只是為了方便。

2.3 修改操作

template <class T>
class LinkedList{
public:
	...
	//修改操作
	void set(int index, T num);
	...
};

修改操作只有一個函式
set（修改指定位置的值）
同理，在類體內進行修改函式的原型說明，然後在類體外實現。

template <class T>
void LinkedList<T>::set(int index, T num){
	Node<T> *node = head.next;
	for (int i = 0; i < index; ++i, node = node->next);
	node->m_data = num;
}

2.4 查詢操作

template <class T>
class LinkedList{
public:
	...
	//查詢操作
	T get(int index);
	T getFirst();
	T getLast();
	bool contains(T num);
	...
};

查詢函式有四個：
get（返回特定位置元素）
getFirst（返回第一個元素）
getLast（返回最後一個元素）
contains（返回是否包含特定元素）
這裡並沒有實現 find 函式，因為即使獲得了元素位置索引，也不能像陣列一樣方便的再次通過位置索引獲得資料，依然需要遍歷連結串列來獲得資料。
分別對它們進行實現。

template <class T>
T LinkedList<T>::get(int index){
	if (index < 0 || index >= m_size){
		cout << "訪問位置非法！" << endl;
		return NULL;
	}
	Node<T> *node = head.next;
	for (int i = 0; i < index; ++i, node = node->next);
	return node->m_data;
}

template <class T>
T LinkedList<T>::getFirst(){
	return get(0);
}
template <class T>
T LinkedList<T>::getLast(){
	return get(m_size - 1);
}
template <class T>
bool LinkedList<T>::contains(T num){
	Node<T> *node = head.next;
	while(node){
		if (node->m_data == num){
			return true;
		}
		node = node->next;
	}
	return false;
}

同理，這裡 get 函式的“訪問位置非法”後面返回的 NULL 也可以用 throw 拋異常來實現，這裡只是為了方便。

2.5 其他操作

連結串列還有一些其他的操作，這些函式我在類體內進行了實現。
包括 連結串列長度 的查詢，還有 連結串列的列印 等操作。

template <class T>
class LinkedList{
public:
	...
	int size(){
		return m_size;
	}
	bool isEmpty(){
		return m_size == 0;
	}
	void print(){
		cout << "LinkedList: ";
		cout << "Size = " << m_size << endl;
		Node<T> *node = head.next;
		while(node){
			cout << node->m_data << "->";
			node = node->next;
		}
		cout << "NULL" << endl;
	}
	...
};

3. 演算法複雜度分析

3.1 增加操作

函式 最壞複雜度 平均複雜度
add O(n) O(n/2) = O(n)
addFirst O(1) O(1)
addLast O(n) O(n)

這裡的時間複雜度與陣列相反，原因在於，引起陣列時間複雜度增加的是元素的移動，而引起連結串列時間複雜度增加的是元素的遍歷。

3.2 刪除操作

函式 最壞複雜度 平均複雜度
remove O(n) O(n/2) = O(n)
removeFirst O(1) O(1)
removeLast O(n) O(n)

同理，刪除操作的時間複雜度與陣列也相反。

3.3 修改操作

函式 最壞複雜度 平均複雜度
set O(n) O(n/2) = O(n)

3.4 查詢操作

函式 最壞複雜度 平均複雜度
get O(n) O(n/2) = O(n)
getFirst O(1) O(1)
getLast O(n) O(n)
contains O(n) O(n/2) = O(n)

總體情況：

操作 時間複雜度
增 O(n)
刪 O(n)
改 O(n)
查 O(n)

因為連結串列需要遍歷，所以操作的複雜度都是 O(n) 級別的，但是，如果只針對頭結點操作，那麼操作時間複雜度就會變成 O(1) 級別。

4. 完整程式碼

程式完整程式碼（這裡使用了標頭檔案的形式來實現類）如下：

#ifndef __LINKEDLIST_H__
#define __LINKEDLIST_H__

using namespace std;

template <class T>
class Node{
public:
	Node(T num = NULL, Node *next = NULL){
		m_data = num;
		this->next = next;
	}
public:
	T m_data;
	Node *next;
};
template <class T>
class LinkedList{
public:
	LinkedList(){
		head.m_data = NULL;
		head.next = NULL;
		m_size = 0;
	}
	int size(){
		return m_size;
	}
	bool isEmpty(){
		return m_size == 0;
	}
	void print(){
		cout << "LinkedList: ";
		cout << "Size = " << m_size << endl;
		Node<T> *node = head.next;
		while(node){
			cout << node->m_data << "->";
			node = node->next;
		}
		cout << "NULL" << endl;
	}
	//增加操作
	void add(int index, T num);
	void addFirst(T num);
	void addLast(T num);
	//刪除操作
	T remove(int index);
	T removeFirst();
	T removeLast();
	void removeElement(T num);
	//修改操作
	void set(int index, T num);
	//查詢操作
	T get(int index);
	T getFirst();
	T getLast();
	bool contains(T num);
private:
	Node<T> head;
	int m_size;
};

template <class T>
void LinkedList<T>::add(int index, T num){
	if (index < 0 || index > m_size){
		cout << "新增位置非法！" << endl;
		return;
	}
	Node<T> *node = &head;
	for (int i = 0; i < index; ++i, node = node->next);
	node->next = new Node<T>(num, node->next);
	m_size++;
}
template <class T>
void LinkedList<T>::addFirst(T num){
	add(0, num);
}
template <class T>
void LinkedList<T>::addLast(T num){
	add(m_size, num);
}

template <class T>
T LinkedList<T>::remove(int index){
	if (index < 0 || index >= m_size){
		cout << "刪除位置非法！" << endl;
		return NULL;
	}
	Node<T> *node = &head;
	for (int i = 0; i < index; ++i, node = node->next);
	Node<T> *p = node->next;
	T res = p->m_data;
	node->next = p->next;
	delete p;
	m_size--;
	return res;
}
template <class T>
T LinkedList<T>::removeFirst(){
	return remove(0);
}
template <class T>
T LinkedList<T>::removeLast(){
	return remove(m_size - 1);
}
template <class T>
void LinkedList<T>::removeElement(T num){
	if (!head.next){
		return;
	}
	Node<T> *node = &head;
	Node<T> *p;
	while(node){
		p = node->next;
		if (p->m_data == num){
			node->next = p->next;
			delete p;
			m_size--;
			return;
		}
		node = p;
	}
}

template <class T>
void LinkedList<T>::set(int index, T num){
	Node<T> *node = head.next;
	for (int i = 0; i < index; ++i, node = node->next);
	node->m_data = num;
}

template <class T>
T LinkedList<T>::get(int index){
	if (index < 0 || index >= m_size){
		cout << "訪問位置非法！" << endl;
		return NULL;
	}
	Node<T> *node = head.next;
	for (int i = 0; i < index; ++i, node = node->next);
	return node->m_data;
}

template <class T>
T LinkedList<T>::getFirst(){
	return get(0);
}
template <class T>
T LinkedList<T>::getLast(){
	return get(m_size - 1);
}
template <class T>
bool LinkedList<T>::contains(T num){
	Node<T> *node = head.next;
	while(node){
		if (node->m_data == num){
			return true;
		}
		node = node->next;
	}
	return false;
}

#endif

相關推薦

資料結構實現 2.1：連結串列（C++版）

1. 概念及基本框架 連結串列 是一種 線性結構 ，而且儲存上屬於 鏈式儲存（即記憶體的物理空間是不連續的），是線性表的一種。連結串列結構如下圖所示： 下面以一個我實現的一個簡單的連結串列類來進一步理解連結串列。 template <class T&g

資料結構實現 8.1：字典樹（C++版）

資料結構實現 8.1：字典樹（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 增加操作 2.2 查詢操作 2.3 其他操作 3. 演算法複雜度分析 3.1 增加操作 3.2 查

資料結構實現 10.1：AVL樹（C++版）

資料結構實現 10.1：AVL樹（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 增加操作 2.1.1 左左 2.1.2 右右 2.1.3 左右 2.1.4 右左 2.1

資料結構實現（五）：連結串列（C++版）

資料結構實現（五）：連結串列（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 增加操作 2.2 刪除操作 2.3 修改操作 2.4 查詢操作 2.5 其他操作 3. 演算法複雜度分析

玩轉資料結構——第四章：連結串列和遞迴

內容概要： Leetcode中和連結串列相關的問題 測試自己的Leetcode連結串列程式碼 遞迴繼承與遞迴的巨集觀語意 連結串列的天然遞迴結構性質 遞迴執行機制：遞迴的微觀解讀 遞迴演算法的除錯 更多和連結串列相關的問題 1-Leetcode中

資料結構實現 5.1：對映_基於樹實現（C++版）

資料結構實現 5.1：對映_基於樹實現（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 增加操作 2.2 刪除操作 2.3 修改操作 2.4 查詢操作 2.5 其他操作 3. 演算法複

資料結構實現 9.1：並查集_陣列結構實現（C++版）

資料結構實現 9.1：並查集_陣列結構實現（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 聯合操作 2.2 查詢操作 2.3 其他操作 3. 演算法複雜度分析 3.1 聯合操作

資料結構實現 6.1：二叉堆_基於動態陣列實現（C++版）

資料結構實現 6.1：二叉堆_基於動態陣列實現（C++版） 1. 概念及基本框架 1.1 滿二叉樹 1.2 完全二叉樹 2. 基本操作程式實現 2.1 增加操作 2.2 刪除操作 2.3 查詢操作

資料結構實現 4.1：集合_基於二分搜尋樹實現（C++版）

資料結構實現 4.1：集合_基於二分搜尋樹實現（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 增加操作 2.2 刪除操作 2.3 查詢操作 2.4 其他操作 3. 演算法複雜度分析

資料結構實現 3.1：二分搜尋樹（C++版）

資料結構實現 3.1：二分搜尋樹（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 增加操作 2.2 刪除操作 2.3 查詢操作 2.4 遍歷操作 2.5 其他操作 3. 演算法複雜度分

C++資料結構與STL--雙向迴圈連結串列（實現自定義iterator類）

class dLinkList {private:node<T> *head;  //頭節點size_t length; //連結串列長度void dInsert(node<T> *curr,T val)  //插入的輔助函式,把新節點插入curr前 {node<T>* t

資料結構：連結串列（指標+遊標）

指標實現連結串列 沒什麼好廢話的， 註釋在程式碼中 #include<cstdio> #include<cstring> #include<algorithm> using namespace std; typedef

資料結構實現（四）：迴圈佇列（C++版）

資料結構實現（四）：迴圈佇列（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 入隊操作 2.2 出隊操作 2.3 查詢操作 2.4 其他操作 3. 演算法複雜度分析 3.1 入

資料結構實現（三）：陣列佇列（C++版）

資料結構實現（三）：陣列佇列（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 入隊操作 2.2 出隊操作 2.3 查詢操作 2.4 其他操作 3. 演算法複雜度分析 3.1 入

資料結構實現（二）：陣列棧（C++版）

資料結構實現（二）：陣列棧（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 入棧操作 2.2 出棧操作 2.3 查詢操作 2.4 其他操作 3. 演算法複雜度分析 3.1 入棧

資料結構實現（一）：動態陣列（C++版）

資料結構實現（一）：動態陣列（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 增加操作 2.2 刪除操作 2.3 修改操作 2.4 查詢操作 2.5 其他操作 3. 演算法複雜度分析

資料結構與演算法-----單向線性連結串列（逆轉和反向列印）

單向連結串列沒有前指標，所以實現反向列印還是比較麻煩，我們這裡使用遞迴原理解決此問題。 這裡提到逆轉，也就是將單鏈表的next指標指向前一個節點，我們也使用遞迴實現。 // 練習：實現單向線性連

資料結構單鏈表之建立連結串列（尾插法）

接上一篇內容，這次使用尾插法來建立單鏈表： 1.同樣建立連結串列成員結構體： struct listnode { int value; listnode* next; }; 2.然後下面就是通過尾插法建立單鏈表的程式，這裡面稍稍要去理解

java入門---資料結構操作例項之在連結串列（LinkedList）的開頭和結尾新增元素

    以下例項演示瞭如何使用 LinkedList 類的 addFirst() 和 addLast() 方法在連結串列的開頭和結尾新增元素：import java.util.LinkedList; p

連結串列（C語言）

1、連結串列的定義 typedef struct stu { int num; struct stu *next; }stu,*student; 2、連結串列的建立         連結串列是用指標連線起來的線性表，對於連結串列的每個結點，都要給它動態分配記憶體，這