各类链表的使用

#define _CRT_SECURE_NO_WARNINGS
#include<malloc.h>
#include<iostream>
using namespace std;
typedef int ElementType ;//typedef<数据类型><别名>
typedef struct LNode {
	struct LNode* next;//?
	ElementType data;
}LNode,*LinkList;
/*	强调这是一个单链表:LinkList
	强调这是一个结点:  LNode*
*/
/*上面这段代码等价于
typedef struct LNode LNode;
struct LNode{
	struct LNode* next;
	ElementType data;
};
*/
//不带头指针版
bool InitList1(LinkList& L) {//指针取模,得到指针所指向内存空间的位置
	L = NULL;
	return true;
}
//带头结点版,这个更方便
bool InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;//在大多数情况下可以写成nullptr
	return true;
}
//插入元素,带头结点版.这样也可以插入在第一位,而不带头结点则不可以,(可以把头结点看做第0个结点)
bool ListInsert(LinkList& L, int i, ElementType e) {
	if (i < 1)
		return false;//位置不合法
	LNode* p;
	int j = 0;
	//这一段是用作不带头结点时插入第一个数据的
	//if (i == 1) {
	//	LNode* s = (LNode*)malloc(sizeof(LNode));
	//	s->data = e;
	//	s->next = L;
	//	L = s;//头结点指向新的结点
	//	return true;
	//}
	p = L;//记录p指向当前节点
	while (p != NULL && j < i - 1) {//找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p == NULL)
		return false;
	//创建新节点并插入
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}
//后入
bool InsertNextNode(LNode* p, ElementType e) {
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->next = p->next;
	p->next = s;
	s->data = e;
	return true;
}
//前入
bool InsertPriorNode(LNode* p, ElementType e) {
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->next = p->next;
	p->next = s;
	s->data = p->data;//这一段代码从这里开始和上一段不同.采用了一种巧妙地"山不过来我过去"的想法,先在节点后创建一个新节点,再将两结点内数据交换
	p->data = e;//新数据放进原结点
	return true;
}
//按照位序删除
bool ListDelete(LinkList &L,int i,ElementType &e) {
	//LNode *p=GetElem(L, i);//获取位置
	if (i < 0)
		return NULL;
	int j = 0;
	LNode* p = L;
	while (p != NULL && j < i) {
		j++;
		p = p->next;
	}
	if (p == NULL)
		return NULL;
	return p;
	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);//释放内存
	return true;
}
//按照指定节点删除
bool NodeDelete(LNode* p) {
	if (p == NULL)
		return false;
	p->next = p->next->next;
	p->data = p->next->data;
	free(p->next);
	/*和先前一样,也是类似偷梁换柱,实际删去了后一个结点,并且交换了两个结点之间的数据
	但是当p是最后一个结点是,就只能从表头依次找到结点的前驱来删除啦(大悲)
	这也是单链表的局限性(只能单向检索)*/
	return true;
}
//按位查找(带头结点)
LNode* GetElem(LinkList &L, int i) {
	if (i < 0)
		return NULL;
	int j = 0;
	LNode* p = L;
	while (p != NULL && j < i) {
		j++;
		p = p->next;
	}
	if (p == NULL)
		return NULL;
	return p;
}
//按值查找
LNode* LocateElem(LinkList L, ElementType e) {
	LNode* p = L;
	while (p->data != e && p != NULL)
		p = p->next;
	return p;
}
//单链表的建立:尾插法
LinkList List_TailInsert(LinkList& L) {
	ElementType x;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	LNode* s, * r = L;//指针r指向最后一个结点
	scanf("%d", &x);
	while (x != 114514) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf("%d", &x);
	}
	r->next = nullptr;
	return L;
}
//头插法,同样原理适用于链表逆置
LinkList List_HeadInsert(LinkList& L) {
	ElementType x;
	LNode* s;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	scanf("%d", &x);
	while (x!=114514)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;//将新元素插入到头结点之后
		L->next = s;
		scanf("%d", &x);
	}
	return L;
}
bool ListShow(LinkList L) {
	LNode* p = L->next;
	while (p!=NULL)
	{
		cout << p->data << " " ;
		if (p->next != NULL)
			p = p->next;
		else
			return true;
	}
	return false;
}
//单链表就地逆置
bool reverList(LinkList &L) {
	if (L->next == NULL || L->next == NULL)
		return true;
	LNode* p = L->next;
	L->next = NULL;//断开原有结点
	while (p!=NULL)
	{
		LNode* temp = p->next;
		p->next = L->next;
		L->next = p;
		p = temp;
	}
	return true;
}
int main()
{
	LinkList L;
	List_HeadInsert(L);
	ListShow(L);
	reverList(L);
	ListShow(L);
	return 0;
}

整体代码如上,.需要注意的是.在使用链表时,应该注意一些特殊位置,比如头结点和尾结点.而带头结点的创建方式之所以相对于无头结点来说更好,就是可以使对第一个数据更改变得不再"特殊",比如可以直接在第一个位置插入.

而在代码健壮性方面,需要注意的是尾结点的next指针域为NULL,可以通过if条件句的判断来增加代码的健壮性.值得注意的是,头插法的思路也用于链表原地逆置(不是使用新的链表,不断将最后一个元素插入值第一个)

链表的其他变种(如双链表,但循环链表,双循环链表)只是对节点结构体定义进行略微修改,并且不同链表在判断什么时候链表遍历到最后一位时代码不同.

接下来介绍静态链表.静态链表分配一片集中的空间.

typedef int ElementType;
#define MaxLen 20
struct Node {
	ElementType data;
	int next;//存放数组下标
}SLinkList[MaxLen];//这一种写法似乎更能表示SLinkList是一个静态链表,而不是一个数组
//typedef struct 

然而,静态链表不能增加链表长度,在链表声明时,长度已经固定.所以,这并不是一个非常重要的考点.