資料結構實現 5.2：對映_基於連結串列實現（C++版）

阿新 • • 發佈：2018-11-27

資料結構實現 5.2：對映_基於連結串列實現（C++版）

1. 概念及基本框架
2. 基本操作程式實現

2.1 增加操作
2.2 刪除操作
2.3 修改操作
2.4 查詢操作
2.5 其他操作

3. 演算法複雜度分析

3.1 增加操作
3.2 刪除操作
3.3 修改操作
3.4 查詢操作

4. 完整程式碼

1. 概念及基本框架

.
在 5.1 中我們通過 二分搜尋樹 來實現了對映，這一節我們通過 連結串列 來實現對映。

對映的基本特性依然要滿足：
1.對映內元素包含 鍵（key） 和 值（value） ，而且一一對應。
2.對映內的元素的鍵 不能重複 。
注：有些對映（多重對映）中元素的鍵也可以重複。
在 2.1 中實現的連結串列結點只有一個數據，所以我們需要從底層進行一些改進去適應對映這一資料結構。首先來定義連結串列的結點類：

template <class K, class V>
class MapNode{
public:
	MapNode(K key = NULL, V value = NULL, MapNode<K, V> *next = NULL){
		m_key = 
 key;
		m_value = value;
		this->next = next;
	}
public:
	K m_key;
	V m_value;
	MapNode<K, V> *next;
};

這個結點類的內部也顯式的給出了建構函式，下面通過結點類來建立一個對映類。
注：這裡我們也可以先實現一個連結串列類，然後通過連結串列來實現對映類。
有了改進版的連結串列結點，我們就可以利用一個由 純虛擬函式 構成的 抽象類 作為一個介面來定義這些操作。具體程式碼如下：

template <class K, class V>
class Map{
public: 

	virtual int size() = 0;
	virtual bool isEmpty() = 0;
	//增加操作
	virtual void add(K key, V value) = 0;
	//刪除操作
	virtual V remove(K key) = 0;
	//修改操作
	virtual void set(K key, V value) = 0;
	//查詢操作
	virtual bool contains(K key) = 0;
	virtual V get(K key) = 0;
};

下面只需要通過繼承 抽象類，並且重寫 純虛擬函式 ，就可以完成對映的實現。對映類的框架如下：

template <class K, class V>
class LinkedListMap : public Map<K, V>{
public:
	LinkedListMap(){
		head.m_key = NULL;
		head.m_value = NULL;
		head.next = NULL;
		m_size = 0;
	}
	...
private:
	MapNode<K, V> head;
	int m_size;
};

這裡為了避免重複設計就可以相容更多資料型別，引入了泛型，即模板的概念。（模板的關鍵字是 class 或 typename）
這裡連結串列加了虛擬頭結點，同樣，為了保護資料，變數設定為 private 。
實現了前面的程式之後，接下來就是一個對映的增、刪、改、查以及一些其他基本操作，接下來利用程式碼去實現。

2. 基本操作程式實現

2.1 增加操作

template <class K, class V>
class LinkedListMap : public Map<K, V>{
public:
	...
	//增加操作
	void add(K key, V value){
		if (!contains(key)){
			MapNode<K, V> *p = new MapNode<K, V>(key, value, head.next);
			head.next = p;
			m_size++;
		}
	}
	...
};

需要查詢連結串列是不是已經包含該鍵。

2.2 刪除操作

template <class K, class V>
class LinkedListMap : public Map<K, V>{
public:
	...
	//刪除操作
	V remove(K key){
		MapNode<K, V> *pre = &head;
		MapNode<K, V> *node = pre->next;
		while (node){
			if (key == node->m_key){
				pre->next = node->next;
				V res = node->m_value;
				delete node;
				m_size--;
				return res;
			}
			pre = node;
			node = node->next;
		}
		cout << "對映中不包含" << key << '!' << endl;
		return NULL;
	}
	...
};

2.3 修改操作

template <class K, class V>
class LinkedListMap : public Map<K, V>{
public:
	...
	//修改操作
	void set(K key, V value){
		MapNode<K, V> *node = head.next;
		while (node){
			if (key == node->m_key){
				node->m_value = value;
				return;
			}
			node = node->next;
		}
		cout << "對映中不包含" << key << '!' << endl;
	}
	...
};

2.4 查詢操作

template <class K, class V>
class LinkedListMap : public Map<K, V>{
public:
	...
	//查詢操作
	bool contains(K key){
		MapNode<K, V> *node = head.next;
		while (node){
			if (key == node->m_key){
				return true;
			}
			node = node->next;
		}
		return false;
	}
	V get(K key){
		MapNode<K, V> *node = head.next;
		while (node){
			if (key == node->m_key){
				return node->m_value;
			}
			node = node->next;
		}
		cout << "對映中不包含" << key << '!' << endl;
		return NULL;
	}
	...
};

2.5 其他操作

對映還有一些其他的操作，包括 對映大小 的查詢等操作。

template <class K, class V>
class LinkedListMap : public Map<K, V>{
public:
	...
	int size(){
		return m_size;
	}
	bool isEmpty(){
		return m_size == 0;
	}
	...
};

3. 演算法複雜度分析

3.1 增加操作

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

因為需要判斷是否存在該元素，所以需要遍歷一遍整個連結串列。

3.2 刪除操作

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

3.3 修改操作

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

3.4 查詢操作

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

總體情況：

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

與利用二分搜尋樹實現的對映相比，利用連結串列實現的對映操作的時間複雜度就增大了很多。

4. 完整程式碼

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

抽象類 介面程式碼：

#ifndef __MAP_H__
#define __MAP_H__

template <class K, class V>
class Map{
public:
	virtual int size() = 0;
	virtual bool isEmpty() = 0;
	//增加操作
	virtual void add(K key, V value) = 0;
	//刪除操作
	virtual V remove(K key) = 0;
	//修改操作
	virtual void set(K key, V value) = 0;
	//查詢操作
	virtual bool contains(K key) = 0;
	virtual V get(K key) = 0;
};

#endif

對映類 程式碼：

#ifndef __LINKEDLISTMAP_H__
#define __LINKEDLISTMAP_H__

#include "Map.h"

template <class K, class V>
class MapNode{
public:
	MapNode(K key = NULL, V value = NULL, MapNode<K, V> *next = NULL){
		m_key = key;
		m_value = value;
		this->next = next;
	}
public:
	K m_key;
	V m_value;
	MapNode<K, V> *next;
};

template <class K, class V>
class LinkedListMap : public Map<K, V>{
public:
	LinkedListMap(){
		head.m_key = NULL;
		head.m_value = NULL;
		head.next = NULL;
		m_size = 0;
	}
	int size(){
		return m_size;
	}
	bool isEmpty(){
		return m_size == 0;
	}
	//增加操作
	void add(K key, V value){
		if (!contains(key)){
			MapNode<K, V> *p = new MapNode<K, V>(key, value, head.next);
			head.next = p;
			m_size++;
		}
	}
	//刪除操作
	V remove(K key){
		MapNode<K, V> *pre = &head;
		MapNode<K, V> *node = pre->next;
		while (node){
			if (key == node->m_key){
				pre->next = node->next;
				V res = node->m_value;
				delete node;
				m_size--;
				return res;
			}
			pre = node;
			node = node->next;
		}
		cout << "對映中不包含" << key << '!' << endl;
		return NULL;
	}
	//修改操作
	void set(K key, V value){
		MapNode<K, V> *node = head.next;
		while (node){
			if (key == node->m_key){
				node->m_value = value;
				return;
			}
			node = node->next;
		}
		cout << "對映中不包含" << key << '!' << endl;
	}
	//查詢操作
	bool contains(K key){
		MapNode<K, V> *node = head.next;
		while (node){
			if (key == node->m_key){
				return true;
			}
			node = node->next;
		}
		return false;
	}
	V get(K key){
		MapNode<K, V> *node = head.next;
		while (node){
			if (key == node->m_key){
				return node->m_value;
			}
			node = node->next;
		}
		cout << "對映中不包含" << key << '!' << endl;
		return NULL;
	}
private:
	MapNode<K, V> head;
	int m_size;
};

#endif

資料結構實現 5.2：對映_基於連結串列實現（C++版）