数据结构与算法笔记（三）线性表（链式描述）链表

在链式描述中，线性表元素的位置在内存中是随机的，每个元素都有一个明确的指针指向线性表的下一个元素的位置。

1.单向链表：
数据对象的每一个元素都用一个单元或者节点来描述，每个节点都明确包含另一个相关节点的位置信息。

线性表的链式描述图如下所示：

每个节点只有一个链，这种结构称为单向链表

重点：链表的插入与删除

结构chainNode,数据成员element是节点的数据域，存储线性表的元素，数据成员next是节点的链域，存储下一个节点的指针。

定义链表类chain:

首先定义链表的节点的数据结构，结构体chainNode;

template<typename T>
struct chainNode    // 定义节点的数据结构
{// 数据成员T element;    // 数据域 chainNode<T>* next;     // 指针域//chainNode() {}chainNode(T& element)   // 结构体的构造函数 {this->element = element;} chainNode(T& element, chainNode<T>* next)   // 结构体的构造函数 {this->element = element;    // 这里的this的作用类似于类里面的this this->next = next;}
};

链表类chain的定义:

template<typename T>
class chain: public linearList<T>
{protected:bool checkIndex(int theIndex) const;   // 索引是否有效 chainNode<T>* firstNode;int listSize;public:chain(int init_capacity=10);chain(const chain<T>&);   // 拷贝构造函数~chain();    // 析构函数//抽象数据类型ADTbool empty() const;int size() const;T& get(int index);int indexOf(T& element) const;void erase(int index);void insert(int index);void output() const;
};

重点掌握的，链表的拷贝构造函数实现，析构函数实现，插入函数和删除函数

拷贝构造函数：

template<typename T>
chain<T>::chain(const chain<T>& new_chain)  // 重要
{listSize = new_chain.listSize;if(listSize==0)   // 要复制的链表为空 {firstNode = NULL;return;   // end}// 链表非空chainNode<T>* sourceNode = new_chain.firstNode;firstNode = new chainNode<T>(sourceNode->element);   // 结构体变量的初始化  chainNode结构体有两个构造方法，这是其中的一个 // firstNode = new chainNode<T>((*sourceNode).element) //解引用sourceNode = sourceNode->next;           // 原来链表的指针 chainNode<T>* targetNode = firstNode;   // 复制得到的链表的节点指针 while(sourceNode!=NULL){targetNode->next = new chainNode<T>(sourceNode->element);targetNode = targetNode->next;sourceNode = sourceNode->next;} targetNode->next = NULL;   // 链表结束
}

指针移动细节如下图所示：

析构函数：

析构函数逐个删除链表的节点，通过重复清除链表的首个元素节点，知道链表为空。在清除之前用变量保存第二个元素节点的指针。时间复杂度 $\Theta (listSize)$

template<typename T>
chain<T>::~chain()
{// 链表的析构函数， 删除链表的所有节点while(firstNode!=NULL){chainNode<T>* nextNode = firstNode->next;  // 保存链表第二个节点的指针 delete firstNode;     // 删除释放第一个节点的内存 firstNode = nextNode;    // 将第二个节点变为第一个节点 }
}

链表类chain的完整代码：
1. chain的基类, 抽象类linearList

#ifndef LINEAR_LIST_H
#define LINEAR_LIST_H #include <iostream>
using namespace std;template<typename T>    // 定义一个抽象类
class linearList
{public:// 抽象类中的纯虚函数 virtual ~linearList()  {};   // 析构函数virtual bool empty() const=0;virtual int size() const=0;virtual T& get(int index) const=0;virtual int indexOf(const T x) const=0;     // 这里定义的是虚函数，虚函数virtual functiuonName() const=0表示的是定义为纯虚函数，这个纯虚函数是只读函数 virtual void erase(int index) = 0;           // 这里定义的是虚函数，虚函数virtual functiuonName()=0表示的是定义为纯虚函数，这个纯虚函数不是只读函数virtual void insert(int index, T x) = 0;// virtual void output(ostream& out) const=0;
};#endif

2. 类chain的定义和实现：

#ifndef CHAIN_H
#define CHAIN_H
#include <iostream>#include "E:\back_up\code\c_plus_code\digui\external_file\linearlist.h"template<typename T>
struct chainNode    // 定义节点的数据结构
{// 数据成员T element;    // 数据域 chainNode<T>* next;     // 指针域//chainNode() {}chainNode(T& element)   // 结构体的构造函数 {this->element = element;} chainNode(T& element, chainNode<T>* next)   // 结构体的构造函数 {this->element = element;    // 这里的this的作用类似于类里面的this this->next = next;}
};template<typename T>
class chain: public linearList<T>
{protected://bool checkIndex(int theIndex) const;   // 索引是否有效 chainNode<T>* firstNode;int listSize;public:chain(int init_capacity=10);chain(const chain<T>& new_chain);   // 拷贝构造函数~chain();    // 析构函数//抽象数据类型ADTbool empty() const;int size() const;T& get(int index) const;int indexOf(T x) const;void erase(int index);void insert(int index, T x);void output() const;
};/*
template<typename T>
bool chain<T>::checkIndex(int index)
{return (index>=0&&index<=listSize)?true:false;
}
*/template<typename T>
chain<T>::chain(int init_capacity)   // 构造函数
{if(init_capacity<1)cout << "Init capacity should be greater than 0" << endl;firstNode = NULL;      // 链表初始化 listSize = 0;
}
#endiftemplate<typename T>
chain<T>::chain(const chain<T>& new_chain)  // 重要
{listSize = new_chain.listSize;if(listSize==0)   // 要复制的链表为空 {firstNode = NULL;return;   // end}// 链表非空chainNode<T>* sourceNode = new_chain.firstNode;firstNode = new chainNode<T>(sourceNode->element);   // 结构体变量的初始化  chainNode结构体有两个构造方法，这是其中的一个 // firstNode = new chainNode<T>((*sourceNode).element) //解引用sourceNode = sourceNode->next;           // 原来链表的指针 chainNode<T>* targetNode = firstNode;   // 复制得到的链表的节点指针 while(sourceNode!=NULL){targetNode->next = new chainNode<T>(sourceNode->element);targetNode = targetNode->next;sourceNode = sourceNode->next;} targetNode->next = NULL;   // 链表结束
}template<typename T>
chain<T>::~chain()
{// 链表的析构函数， 删除链表的所有节点while(firstNode!=NULL){chainNode<T>* nextNode = firstNode->next;  // 保存链表第二个节点的指针 delete firstNode;     // 删除释放第一个节点的内存 firstNode = nextNode;    // 将第二个节点变为第一个节点 }
}template<typename T>
bool chain<T>::empty() const
{return listSize==0;
} template<typename T>
int chain<T>::size() const
{return listSize;
}template<typename T>
T& chain<T>::get(int index) const
{/*if(checkIndex(index)){chainNode<T>* currentNode = firstNode;for(int i=0; i<index; i++){currentNode = currentNode->next;    //先找到index的前一个节点 }return currentNode->element; }else{cout << "The index is invalid" << endl;}*/chainNode<T>* currentNode = firstNode;for(int i=0; i<index; i++){currentNode = currentNode->next;    //先找到index的前一个节点 }return currentNode->element;
}template<typename T>
int chain<T>::indexOf(T the_element) const
{// 返回the_element首次出现的索引值// fouzefanhui -1chainNode<T>* currentNode = firstNode;int index_cnt = 0;while(currentNode!=NULL){if(currentNode->element == the_element){return index_cnt;}currentNode = currentNode->next;index_cnt ++;} return -1;
}template<typename T>
void chain<T>::insert(int index, T x)
{// 在链表中插入元素//chainNode<T>* currentNode = firstNode;// 插入元素得考虑是否在表头插入；if(index==0)   // 在表头插入 {firstNode = new chainNode<T>(x, firstNode);   // 造结构体构造方法 //firstNode->next = currentNode;} else           // 不是在表头插入 {chainNode<T>* currentNode = firstNode; for(int i=0; i<index-1; i++){currentNode = currentNode->next;}currentNode->next = new chainNode<T>(x, currentNode->next);   // 插入元素到链表index位置 }listSize++;
}template<typename T>
void chain<T>::erase(int index)
{// 1.检查index的合法性// 2.检查index==0if(index==0){chainNode<T>* currentNode = firstNode;firstNode = firstNode->next;delete currentNode;listSize--;} else{chainNode<T>* currentNode = firstNode;// int node_cnt = 0;for(int i=0; i<index-1; i++){currentNode = currentNode->next;}// currentNode 指向第index-1个节点chainNode<T>* tmp = currentNode->next;    // tmp指向第index个节点currentNode->next = tmp->next;delete tmp; listSize--;}}template<typename T>
void chain<T>::output() const
{chainNode<T>* currentNode = firstNode;int node_cnt = 0;while(currentNode!=NULL)   //遍历链表的所有元素{cout << currentNode->element << " ";if((node_cnt+1)%10==0){cout << endl;}currentNode = currentNode->next;node_cnt++;}
}

3。测试函数：
main.cpp

#include <iostream>
#include <string>
#include <time.h>
#include "E:\back_up\code\c_plus_code\digui\external_file\linearlist.h"
#include "E:\back_up\code\c_plus_code\digui\external_file\arraylist.h"
#include "E:\back_up\code\c_plus_code\digui\external_file\chain.h"using namespace std;// 实现友元函数int main(int argc, char *argv[])
{/*arrayList<double> array(3);for(int i=0; i<10; i++){array.insert(i, i);}//array.insert(0, a);//array.insert(1, b);array.output();array.insert(9, 9.9);array.output();*/chain<int> chain_1;for(int i=0; i<10; i++){chain_1.insert(i, i*i);}cout << "The size of chain is " << chain_1.size() << endl;chain_1.output();// cout << "The size of chain is " << chain_1.get() << endl;chain_1.insert(3, 520);cout << "The size of chain is " << chain_1.size() << endl;chain_1.output();chain_1.erase(9);cout << "The size of chain is " << chain_1.size() << endl;chain_1.output();cout << "The " << 3 << " element in chain is " << chain_1.get(3) << endl;return 0;
}

测试结果：

------------------------------------------------------------------------------------------------

给类chain添加clea()功能：

template<typename T>
void chain<T>::clear()
{while(firstNode!=NULL){chainNode<T>* nextNode = firstNode->next;delete firstNode;firstNode = nextNode;}listSize = 0;
}

main.cpp

#include <iostream>
#include <string>
#include <time.h>
#include "E:\back_up\code\c_plus_code\digui\external_file\linearlist.h"
#include "E:\back_up\code\c_plus_code\digui\external_file\arraylist.h"
#include "E:\back_up\code\c_plus_code\digui\external_file\chain.h"using namespace std;// 实现友元函数int main(int argc, char *argv[])
{/*arrayList<double> array(3);for(int i=0; i<10; i++){array.insert(i, i);}//array.insert(0, a);//array.insert(1, b);array.output();array.insert(9, 9.9);array.output();*/chain<int> chain_1;for(int i=0; i<10; i++){chain_1.insert(i, i*i);}cout << "The size of chain is " << chain_1.size() << endl;chain_1.output();chain_1.clear();if(chain_1.empty()){cout << "The chain is empty" << endl;}else{cout << "The chain is not empty" << endl;}return 0;
}

测试结果：

性能比较：

1.内存比较：

在数组描述的线性表中，数组满的时候，数组的长度需要加倍，，当线性表的元素个数不及数组长度的1/4时，数组元素减半。

n个元素的线性表可以存储在n~4n长度的数组中。假设每个元素需要s个字节，则所占的空间为ns~4ns.对于链表，n个元素分配n个节点，每个指针4字节大小，则所占的空间的小为n(s+4),因此在选择线性表的描述方法时，空间上的差异不是决定因素。

2.时间比较

例如get(int index)操作，链表的时间复杂度是 $\Theta (listSize)$ ,数组的时间复杂度是 $\Theta (1)$ ，其他操作的时间如下：

--------------------------------------------------f分割线--------------------------------------------------------

给链表添加一些新的方法

1.实现 setSize()方法：