数据结构C++实现——线性表之链表(单链表)

线性表分为顺序表与链表

其中链表分为单链表、双链表、循环链表(这三个为指针实现)与静态链表(数组实现)

指针实现的链表可以分为带头结点与不带头结点两种

其基本操作有插入、删除、按位查找、按值查找等

单链表，不带头结点:

/*
单链表（不带头结点）：用链式存储方式实现的线性表
*/
#include 
#include 
#include 

using namespace std;

#define ElemType int

typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

//初始化单链表（不带头结点）  与带头结点不同X
bool InitList(LinkList& L) {
	L = NULL;                  //防止脏数据(头指针那块内存空间可能有遗留数据)
	return true;
}

/*需要注意的是，不带头结点的情况下 头指针L本身常会改变 故常必须以引用&方式传入参数（区别于带头结点情形 L指向头结点这个指向本身基本不会变 所以甚至可以不带&）*/
/*本代码中malloc后都会带一个判断返回值不是NULL的if，只是为了不产生警告，没有也可*/


//单链表建立（尾插法 不带头结点）  与带头结点不同X
LinkList List_TailInsert(LinkList& L) {                   //L真的会变，真的一定要有&
	int x;
	LNode* s, * r = L;
	scanf_s("%d", &x);
	s = (LNode*)malloc(sizeof(LNode));
	if (s) {
		s->data = x;
		L = s;
		r = s;
	}
	scanf_s("%d", &x);
	while (x != 999) {
		s = (LNode*)malloc(sizeof(LNode));
		if (s) {
			s->data = x;
			r->next = s;
			r = s;
		}
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return L;
}

//单链表建立（头插法 不带头结点）  与带头结点不同X
LinkList List_HeadInsert(LinkList& L) {               //L真的会变，真的一定要有&
	LNode* s;
	ElemType x;
	scanf_s("%d", &x);
	s = (LNode*)malloc(sizeof(LNode));
	if (s) {
		s->data = x;
		s->next = NULL;
		L = s;
	}
	scanf_s("%d", &x);
	while (x != 999) {
		s = (LNode*)malloc(sizeof(LNode));
		if (s) {
			s->data = x;
			s->next = L;
			L = s;
		}
		scanf_s("%d", &x);
	}
	return L;
}

//按位查找（不带头结点）平均时间复杂度O(n)   与带头结点不同X
LNode* GetElem(LinkList L, int i) {
	int j = 1;                        //计数，初始为1
	LNode* p = L;               //初始指向第1个结点
	if (i <= 0) return NULL;

	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;
}

//按值查找（不带头结点）平均时间复杂度O(n)   与带头结点不同X
LNode* LocateElem(LinkList L, ElemType e, int& i) {
	LNode* p = L;
	i = 1;
	while (p != NULL && p->data != e) {
		p = p->next;
		i++;
	}
	return p;
}

//求表长（不带头结点） 时间复杂度O(n)      与带头结点不同X
int length(LinkList L) {
	int len = 0;
	LNode* p = L;
	while (p != NULL) {
		p = p->next;
		len++;
	}
	return len;
}

//指定结点的后插操作（不带头结点）              与带头结点相同√
bool InsertNextNode(LNode* p, ElemType e) {
	if (p == NULL) return false;               //指定结点为空
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL) return false;               //内存分配失败，不写也可
	s->data = e;
	s->next = p->next;                         //与下一句不可颠倒
	p->next = s;
	return true;
}

//指定结点的前插操作（不带头结点） 时间复杂度O(1) 与带头结点相同√
bool InsertPriorNode(LNode* p, ElemType e) {
	if (p == NULL) return false;               //指定结点为空
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL) return false;               //内存分配失败，不写也可
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
	return true;
}

//指定结点p、s的前插操作（不带头结点）         与带头结点相同√
bool InsertPriorNode2(LNode* p, LNode* s) {
	if (p == NULL || s == NULL) return false;
	s->next = p->next;
	p->next = s;
	ElemType temp = p->data;
	p->data = s->data;
	s->data = temp;
	return true;
}

//按位序插入（不带头结点）                      与带头结点不同X
bool ListInsert(LinkList& L, int i, ElemType e) { 
	if (i < 1) return false;
	if (i == 1)
		return InsertPriorNode(L, e);             //不带头结点，插入位序为1的位置要单独处理，，，因为是用后插实现前插，所以L本身并不会改变
	LNode* p = GetElem(L, i - 1);
	return InsertNextNode(p, e);
}

//按位序删除（不带头结点）                      与带头结点不同X
bool ListDelete(LinkList& L, int i, ElemType& e) {     //L有可能真的会变，真的一定要有&
	if (i < 1) return false;
	if (i == 1) {
		LNode* p = L;
		e = p->data;
		L = L->next;
		free(p);
		return true;
	}
	LNode* p = GetElem(L, i - 1);                   //找到第i-1个结点
	if (p == NULL || p->next == NULL) return false;
	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

//指定结点删除（不带头结点）           与带头结点相同√
bool DeleteNode(LinkList &L, LNode* p) {                
	if (p == NULL) return false;
	LNode* q = p->next;
	if (q == NULL) {                   //是最后一个结点
		LNode* s = L;
		while (s->next != p)
			s = s->next;
		s->next = NULL;
		free(p);
		return true;
	}
	else {                             //不是最后一个结点 时间复杂度O(1)   通过删除后继结点来删除此结点 即使是删除第一个结点 也不会真的改变L内的值
		p->data = q->data;
		p->next = q->next;
		free(q);
		return true;
	}
}

//输出全表                               与带头结点不同X
void PrintList(LinkList L) {
	LNode* s = L;
	while (s != NULL) {
		printf("%d ", s->data);
		s = s->next;
	}
	cout << "\n";
}

int main() {
	LinkList L1, L2;
	InitList(L1);
	InitList(L2);

	cout << "请输入L1的值，空格为界，999结束：\n";
	List_TailInsert(L1);                //单链表建立-尾插法
	cout << "L1(尾插法)：\n";
	PrintList(L1);
	cout << "请输入L2的值，空格为界，999结束：\n";
	List_HeadInsert(L2);                //单链表建立-头插法
	cout << "L2(头插法)：\n";
	PrintList(L2);

	LNode* s1, * s2;                     //注意这里*要每个变量单独加
	s1 = GetElem(L1, 6);                //按位查找
	s2 = GetElem(L2, 9);
	cout << "L1按位查找6结果：\n";
	printf("%d\n", s1->data);
	cout << "L2按位查找9结果：\n";
	printf("%d\n", s2->data);

	int i1 = 0, i2 = 0;
	s1 = LocateElem(L1, 6, i1);
	s2 = LocateElem(L2, 9, i2);
	cout << "L1按值查找6结果/位序：\n";
	printf("%d %d\n", s1->data, i1);
	cout << "L2按值查找9结果/位序：\n";
	printf("%d %d\n", s2->data, i2);

	InsertNextNode(s1, 9);
	InsertPriorNode(s2, 6);
	cout << "指定结点后插操作后L1：\n";
	PrintList(L1);
	cout << "指定结点前插操作后L2：\n";
	PrintList(L2);

	int l1, l2;
	l1 = length(L1);
	l2 = length(L1);
	cout << "L1表长：\n";
	printf("%d\n", l1);
	cout << "L2表长：\n";
	printf("%d\n", l2);

	ListInsert(L1, 1, 69);
	ListInsert(L2, 1, 69);
	cout << "按位序插入操作后L1：\n";
	PrintList(L1);
	cout << "按位序插入操作后L2：\n";
	PrintList(L2);

	ElemType e1;
	ListDelete(L1, 1, e1);
	LNode* s3 = GetElem(L2, 1);
	DeleteNode(L2, s3);
	cout << "按位序删除操作后L1：\n";
	PrintList(L1);
	cout << "指定结点删除操作后L2：\n";
	PrintList(L2);

	s3 = GetElem(L2, 1);
	InsertNextNode(s3, 69);
	cout << "指定结点删除操作后又后插操作后L2：\n";
	PrintList(L2);

	return 0;
}

单链表，带头结点:

/*
单链表（带头结点）：用链式存储方式实现的线性表
*/
#include 
#include 
#include 

using namespace std;

#define ElemType int

typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode,*LinkList;

/*
上述单链表结点类型定义过程等价于<=>：
struct LNode{
    ElemType data;
	struct LNode* next;
};
typedef struct LNode LNode;          //数据类型：struct LNode                                 别名：LNode
typedef struct Lnode* LinkList;      //数据类型：struct LNode* (指向struct LNode类型的指针)   别名：LinkList
*/

//初始化单链表（带头结点）
bool InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL) return false;
	L->next = NULL;
	return true;
}

//单链表建立（尾插法 带头结点）
LinkList List_TailInsert(LinkList& L) {
	int x;
	//L = (LinkList)malloc(sizeof(LNode));  //建立头结点 初始化那里已经做了
	LNode* s, * r = L;
	scanf_s("%d", &x);
	while (x != 999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return L;
}

//单链表建立（头插法 带头结点）
LinkList List_HeadInsert(LinkList& L) {
	LNode* s;
	ElemType x;
	//L = (LinkList)malloc(sizeof(LNode));
	//L->next = NULL;                          //建立头结点 与 头结点next指向NULL（必不可少） 在初始化那里已经完成
	scanf_s("%d", &x);
	while (x != 999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf_s("%d", &x);
	}
	return L;
}

//按位查找（带头结点）平均时间复杂度O(n)
LNode* GetElem(LinkList L, int i) {
	int j = 1;                        //计数，初始为1
	LNode* p = L->next;               //初始指向第1个结点（头结点为第0个）
	if (i == 0) return L;
	if (i < 1) return NULL;
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;
}

//按值查找（带头结点）平均时间复杂度O(n)
LNode* LocateElem(LinkList L, ElemType e,int &i) {
	LNode* p = L->next;
	i = 1;
	while (p != NULL && p->data != e) {
		p = p->next;
		i++;
	}
	return p;
}

//求表长（带头结点）长度中不含头结点，只有头结点长度为0 时间复杂度O(n)
int length(LinkList L) {
	int len = 0;
	LNode* p = L;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}

//指定结点的后插操作（带头结点）
bool InsertNextNode(LNode* p, ElemType e) {
	if (p == NULL) return false;               //指定结点为空
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL) return false;               //内存分配失败，不写也可
	s->data = e;
	s->next = p->next;                         //与下一句不可颠倒
	p->next = s;
	return true;
}

//指定结点的前插操作（带头结点） 时间复杂度O(1)
bool InsertPriorNode(LNode* p, ElemType e) {
	if (p == NULL) return false;               //指定结点为空
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL) return false;               //内存分配失败，不写也可
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
	return true;
}

//指定结点p、s的前插操作（带头结点）
bool InsertPriorNode2(LNode* p, LNode* s) {
	if (p == NULL || s == NULL) return false;
	s->next = p->next;
	p->next = s;
	ElemType temp = p->data;
	p->data = s->data;
	s->data = temp;
	return true;
}

//按位序插入（带头结点）
bool ListInsert(LinkList &L, int i, ElemType e) {
	if (i < 1) return false;
	LNode* p = GetElem(L, i - 1);
	return InsertNextNode(p, e);
}

//按位序删除（带头结点）
bool ListDelete(LinkList& L, int i, ElemType& e) {
	if (i < 1) return false;
	LNode* p = GetElem(L, i - 1);                   //找到第i-1个结点
	if (p == NULL||p->next == NULL) return false;
	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

//指定结点删除（带头结点）
bool DeleteNode(LinkList &L,LNode* p) {
	if (p == NULL) return false;
	LNode* q = p->next;
	if (q == NULL) {                   //是最后一个结点
		LNode *s = L;
		while (s->next != p)
			s = s->next;
		s->next = NULL;
		free(p);
		return true;
	}
	else {                             //不是最后一个结点 时间复杂度O(1)
		p->data = q->data;
		p->next = q->next;
		free(q);
		return true;
	}
}

//输出全表
void PrintList(LinkList L) {
	LNode *s = L->next;
	while (s != NULL) {
		printf("%d ", s->data);
		s = s->next;
	}
	cout << "\n";
}

int main() {
	LinkList L1,L2;
	InitList(L1);
	InitList(L2);

	cout << "请输入L1的值，空格为界，999结束：\n";
	List_TailInsert(L1);                //单链表建立-尾插法
	cout << "请输入L2的值，空格为界，999结束：\n";
	List_HeadInsert(L2);                //单链表建立-头插法

	cout << "L1(尾插法)：\n";
	PrintList(L1);
	cout << "L2(头插法)：\n";
	PrintList(L2);
	
	LNode* s1, *s2;                     //注意这里*要每个变量单独加
	s1 = GetElem(L1, 6);                //按位查找
	s2 = GetElem(L2, 9);
	cout << "L1按位查找6结果：\n";
	printf("%d\n", s1->data);
	cout << "L2按位查找9结果：\n";
	printf("%d\n", s2->data);

	int i1=0, i2=0;
	s1=LocateElem(L1, 6, i1);
	s2=LocateElem(L2, 9, i2);
	cout << "L1按值查找6结果/位序：\n";
	printf("%d %d\n", s1->data,i1);
	cout << "L2按值查找9结果/位序：\n";
	printf("%d %d\n", s2->data,i2);

	InsertNextNode(s1, 9);
	InsertPriorNode(s2, 6);
	cout << "指定结点后插操作后L1：\n";
	PrintList(L1);
	cout << "指定结点前插操作后L2：\n";
	PrintList(L2);

	int l1, l2;
	l1 = length(L1);
	l2 = length(L1);
	cout << "L1表长：\n";
	printf("%d\n",l1);
	cout << "L2表长：\n";
	printf("%d\n",l2);

	ListInsert(L1, 1, 0);
	ListInsert(L2, l2, 69);
	cout << "按位序插入操作后L1：\n";
	PrintList(L1);
	cout << "按位序插入操作后L2：\n";
	PrintList(L2);

	ElemType e1;
	ListDelete(L1, 1, e1);
	LNode *s3 = GetElem(L2,11);
	DeleteNode(L2, s3);
	cout << "按位序删除操作后L1：\n";
	PrintList(L1);
	cout << "指定结点删除操作后L2：\n";
	PrintList(L2);

	s3 = GetElem(L2, 10);
	InsertNextNode(s3, 1);
	cout << "指定结点删除操作后又后插操作后L2：\n";
	PrintList(L2);

	return 0;
}