数据结构——单链表

---

前言

重新学习数据结构，从单链表开始，前面的数组就不看了。
文中图表是用GitMind制作，浏览器搜一下就能在线使用。

---

一、单链表的定义

1.什么是单链表

链表和顺序表（数组）一样，都是在逻辑上线性存储，所以都归于线性表的行列。但在物理存储上不一样，顺序表在逻辑还是物理上都是顺序存储，链表在物理存储上是离散型的存储。这样的存储结构就使得链表可以很方便地改变容量、删除结点、增加结点，但同时也让链表存取一个数据变得很麻烦。

2.定义代码

typedef struct LNode {
	ElemType data;		//数据域
	struct LNode* next;	//指针域
}LNode, *LinkList;

注意：

1. 若定义时不用typedef，则以后使用LNode类型都要加上struct关键字
2. 使用LNode时，是为了强调这是一个结点
3. 使用LinkList时，是为了强调这是一个链表

二、单链表的操作

1.初始化

①带头结点

bool InitList(LinkList &L)
{//初始化一个带头结点的单链表
	L = new LNode;
	if (L == NULL)
		return false;	//内存不足，分配失败
	L->next = NULL;
	return true;
}

头指针指向头结点，头结点的数据域通常不存放数据（也可以用来存放链表长度这样的信息），头结点的指针域所指向的才是链表真正的第一个结点。

补充：new的用法

int* p = new int[5];	//分配5个int类型的空间，并将这片空间的地址给p
int* p = new int(5);	//分配1个int类型的空间，并赋初值5

②不带头结点

bool InitList(LinkList &L)
{//初始化一个不带头结点的空表
	L = NULL;
	return true;
}

2.判空

bool Empty(LinkList L)
{//判断单链表是否为空
	if(L->next == NULL)	//若是不带头结点，则替换为 if(L == NULL)
		return true;
	else
		return false;
}

3.插入

要想在链表（带头结点）的第i个位置插入一个元素，就需要先通过遍历找到第i-1个位置，再创建一个新的结点并把数据e存入新的结点，最后把这个新结点与链表连在一起。
若是不带头结点的链表想插入数据要稍微麻烦些，需要对i=1进行特殊处理多写几行代码，其余部分代码相同。

bool ListInsert(LinkList &L, int i, ElemType e)
{//在单链表第i个位置插入元素e
	if(i < 1)
		return false;	//i值不合法（偏小）
	LNode* p;
	int j = 0;	//用来标记p当前所指的位置
	p = L;
	while (p != NULL && j < i - 1)
	{//通过遍历找到第i-1个位置
		p = p->next;
		j++;
	}
	if (p = NULL)
		return false;	//i值不合法（偏大）
	LNode* s = new LNode;	//创建一个新的结点
	s->data = e;	//把数据e存入新的结点
	/*下面两行代码不能调换位置，否则会使i位置后的所有节点丢失*/
	s->next = p-next;	
	p->next = s;	
	return true;
}

4.指定结点的后插

bool InsertNextNode(LNode* P, ElemType e)
{
	if(p == NULL)	//给定结点有错误
		return false;
	LNode* s = new LNode;	//创建一个新的结点
	s->data = e;	//保存数据
	s->next = p-next;	//连接在给定结点p之后
	p->next = s;
	return true;
} 

5.指定结点的前插

前插比后插麻烦许多，按照正常思路，我们需要先找到p结点的前驱结点，也就是要从头开始遍历来找到p结点前面一个结点，这样时间复杂度为O(n)。但如果我们借鉴后插的操作，先在p结点后面插入一个新的结点，最后把p结点和新结点的数据域交换一下（也就是掉包一下），也可以达成同样的效果，并且时间复杂度只有O(1)。

bool InsertPriorNode(LNode* P, ElemType e)
{
	if(p == NULL)	//给定结点有错误
		return false;
	LNode* s = new LNode;	//创建一个新的结点
	/*像后插一样连接在一起*/
	s->next = p->next;
	p->next = s;
	/*调换数据*/
	s->data = p->data;
	p->data = e;
	return true;
} 

6.删除

要想删除链表（带头结点）中第i个结点，直接找到第i-1个结点，让它连到第i+1个结点，并释放掉第i个结点。
若是不带头结点的链表，想要删除结点，同样需要对i=1时进行特殊处理。

bool ListDelete(LinkList &L, int i, ElemType &e)
{//删除链表L中第i个位置的元素，并用e带回所删除的元素
	if (i < 1)		//i值不合法（偏小）
		return false;
	LNode* p;	//指向当前扫描到的结点
	int j = 0;	//标记当前p指向的结点的位置
	p = L;
	while (p!=NULL && j < i - 1)
	{//通过循环找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p == NULL)	//i值不合法（偏大）
		return false;
	LNode* q = p->next;	//让q指向要被删除的结点
	e = q->data;	//用e带回被删除的元素
	p->next = q->next;	//将结点q从链表中脱离出去
	delete q;	//释放结点中的数据
	return true;	
}

7.指定结点的删除

按照常规思路，要想删除指定的结点，就要找到该结点的前一结点，但这样很麻烦，所以我们可以采用类似前插的思路（掉包）。先将被删结点后一结点中的数据往前移一个结点，这样保证了不想被删除的结点中的数据不会丢失，然后再删除这一结点。
当然，上述方法以及下述代码都只适用于要删除的结点不是最后一个结点的情况，如果非要删除链表中最后一个结点，就必须从表头开始遍历，用常规思路。

bool DeleteNode(LNode* p)
{//在链表中删除指定的结点P
	if(p == NULL)
		return false;
	LNode* q = p->next;	//令q指向被删除结点的下一结点
	p->data = q->data;	//将下一结点的数据转存到p结点中
	p->next = q->next;	//将q结点从链表中脱离出去
	delete q;	//释放q结点中的数据
	return true;
}

8.按位序查找

找到链表（带头结点）中第i个结点，并返回。

LNode* GetElem(LinkList L, int i)
{
	if (i < 1)	//i值不合法（偏小）
		return NULL;
	LNode* p;	//指向当前扫描到的结点
	int j = 0;	//标记p当前所指向的位置
	p = L;
	while (p!=NULL && j < i)
	{//通过循环来让p指针指向第i个结点
		p = p->next;
		j++;
	}
	return p;	//返回该结点
}

9.按值查找

找到链表（带头结点）中值为e的结点，并返回。

LNode* LocateElem(LinkList L, ElemType e)
{
	LNode* p = L->next;	//从第一个结点开始
	while (p->data != e && p != NULL)
		p = p->next;
	return p;	//如果找不到，返回的p就是NULL
}

10.求表长

int Length(LinkList L)
{
	int len = 0;
	LNode* p = L;
	while (p->next != NULL)
	{
		p = p->next;
		len++;
	}
	return len;
}

11.尾插法建立单链表

从头结点开始，一个结点一个结点往后接，每次都是从当前链表的最尾部添加新的结点（越新的结点越远离头结点），以此建立一个链表。

LinkList List_TailInsert(LinkList &L)
{//正向建立单链表
	ElemType _data;	//结点中的数据
	L = new LNode;	//建立头结点
	LNode* s;	//指向当前结点
	LNode* r = L;	//表尾指针
	cin >> _data;
	while (_data != ENDDATA)	//输入ENDDATA表示结束
	{
		s = new LNode;	//新创建一个结点
		s->data = _data;	//把数据存入到新结点
		r->next = s;	//将新结点接到最尾部结点后面
		r = s;	//更新最尾部结点的指针r，使之指向新结点
		cin >> _data;	//输入下一个结点的数据
	}
	r->next = NULL;	//创建结束，将链表最尾部指针后接上NULL
	return L;	//返回创建好的链表
}

12.头插法建立单链表

每次从表头开始插入新结点（越新的结点越靠近头结点），以此建立一个链表。

LinkList List_HeadInsert(LinkList &L)
{//逆向建立单链表
	ElemType _data;	//结点中的数据
	LNode* s;	//指向当前结点
	L = new LNode;	//建立头结点
	L->next = NULL;	//初始为空链表
	cin >> _data;
	while (_data != ENDDATA)	//输入ENDDATA表示结束
	{
		s = new LNode;	//新创建一个结点
		s->data = _data;	//把数据存入到新结点
		/*把新结点连到头结点后面*/
		s->next = L->next;	
		L->next = s;
		cin >> _data;	//输入下一个结点的数据
	}
	return L;	//返回创建好的链表
}

注意：头插法建立的单链表中存放的数据顺序正好与输入数据的顺序相反，所以可以用来将链表逆置。