2024 王道课后代码题 第二章 单链表（全部实现代码）（上）

具体代码如下所示：

void Del_x(LinkList& L, ElemType &x) {
	LNode *p;
	if (L->next->data==x)
	{
			p = L->next;
			L->next = p->next;
			free(p);
			Del_x(L, x);
	}
	else if (L->next->next == NULL && L->next->data == x) {
		p = L->next;
		L->next = NULL;
		free(p);
	}
	else
	{
		Del_x(L->next, x);
	}
}

具体代码如下：

void del_x(LinkList& L, ElemType x) {
	LNode *p,* pre,*q;
	p = L->next;
	pre = L;
	while (p!=NULL)
	{
		if (p->data == x) {
			q = p;
			p = p->next;
			pre->next = p;
			free(q);
		}
		else
		{
			pre = p;
			p = p->next;
		}
	}
}

具体代码：

#include <stdio.h>
#include <malloc.h>

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

LinkList TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;//r为表尾指针
	scanf_s("%d", &x);
	while (x!=-1)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return L;
}

void Print_LinkList(LinkList L) {
	if (L == nullptr || L->next == nullptr) { // 处理链表为空的情况
		printf("cilianbiao wei kong");
	}
	else {
		printf("建立的单链表为:");
		L = L->next;
		while (L != NULL)
		{
			printf("%d->", L->data);
			L = L->next;
		}
	}
}

LinkList Del_min(LinkList& L) {
	if (L == nullptr || L->next == nullptr) { // 处理链表为空的情况
		printf("此链表为空");
		return L;
	}
	LNode* pre = L, * p = pre->next;
	LNode* minpre = pre, * minp = p;
	while (p!=NULL)
	{
		if (p->data < minp->data) {
			minp = p;
			minpre = pre;
		}
		pre = p;
		p = p->next;
	}
	minpre->next = minp->next;
	free(minp);
	return L;
}

int main() {
	int x;
//	LinkList L;
	LinkList L = NULL;
//	L = (LinkList)malloc(sizeof(LNode));
	TailInsert(L);
	Print_LinkList(L);
	Del_min(L);
	printf("\n改变后的单链表为：\n");
	Print_LinkList(L);
}

具体运行结果：

算法思想：利用头插法的原理，来实行单链表的就地逆置，这里要求辅助空间只能为O（1），所以不能借助栈来实现。

具体代码：

#include <stdio.h>
#include <malloc.h>

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

LinkList TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;//r为表尾指针
	scanf_s("%d", &x);
	while (x!=-1)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return L;
}

void Print_LinkList(LinkList L) {
	if (L == nullptr || L->next == nullptr) { // 处理链表为空的情况
		printf("cilianbiao wei kong");
	}
	else {
		printf("建立的单链表为:");
		L = L->next;
		while (L != NULL)
		{
			printf("%d->", L->data);
			L = L->next;
		}
	}
}

void Reverse_L(LinkList& L) {
	LNode* p,*q;//建立一个工作指针
	p = L->next;
	L->next = NULL;
	while (p!=NULL)
	{
		q = p->next;//暂存后继
		p->next = L->next;
		L->next = p;//头插进入
		p = q;//向后遍历
	}
}

int main() {
	int x;
//	LinkList L;
	LinkList L = NULL;
//	L = (LinkList)malloc(sizeof(LNode));
	TailInsert(L);
	Print_LinkList(L);
	Reverse_L(L);
	printf("\n改变后的单链表为：\n");
	Print_LinkList(L);
}

运行结果展示：

算法思想：采用直接插入的算法思想，遍历一遍单链表找出最小值，将其插入到新链表中

具体实现代码：

void sort(LinkList& L) {
	LNode* p, * pre;
	p = L->next;
	LNode* r;
	r = p->next;
	p->next = NULL;//断链
	p = r;
	while (p!=NULL)
	{
		r = p->next;
		pre = L;
		while (pre->next!=NULL&&pre->next->data<=p->data)
		{
			pre = pre->next;//向后遍历查找需要插入节点的前qu
		}
		p->next = pre->next;
		pre->next = p;//插入比前驱节点小的值
		p = r;
	}
}

具体结果演示：

算法思想：遍历链表，将链表的值与给定的两个值一一对应，如果处在这两个链表中间则进行链表节点的删除操作。

具体代码实现：

void delete_s_t(LinkList& L,int s,int t) {
	LNode* p, * pre;//pre为前驱节点，p为L的后继节点
	pre = L;
	p = L->next;
	while (p!=NULL)
	{
		if (p->data > s && p->data < t) {
			pre->next = p->next;
			free(p);
			p = pre->next;
		}
		else
		{
			pre = p;
			p = p->next;
		}

	}
}

具体结果演示:

算法思想：

算法思想：遍历单链表，找出最小的值并找到其前驱节点，输出最小值，并释放该节点，时间度为为O（n2)

具体代码实现：

void delete_min(LinkList& L) {
	LNode *min;
	LNode* pre, * p;//设一个前驱与一个后继
	LNode* pre_min;//设置一个最小值的前趋节点
	pre = L;
	pre_min = pre;
	min = L->next;
	pre = L->next;
	p = pre->next;
	while (L->next!=NULL)
	{
		while (p != NULL) {
			if (p->data < min->data) {
				pre_min = pre;
				min = p;
				pre = p;
				p = p->next;

			}
			else
			{
				pre = p;
				p = p->next;
			}
			printf("%d->", min->data);
			pre_min->next = min->next;
			free(min);
			min = pre_min->next;

		}
	}
}

算法思想：将A链表中的奇数部分链接到A链表中，偶数部分链接到B链表中，要保持其相对顺序不变则需要使用尾插法实现算法。

具体代码：

LinkList Odds_or_ou(LinkList& LA, LinkList& LB) {
	LB = (LinkList)malloc(sizeof(LNode));
	LNode* p = LA->next;
	LA->next = NULL;
	LB->next = NULL;
	LNode* ra = LA, * rb = LB;
	int i = 0;
	while (p != NULL)
	{
		if (i % 2 == 0) {
			rb->next = p;
			rb = p;
		}
		else
		{
			ra->next = p;
			ra = p;
		}
		p = p->next;
	}
	return LA, LB;
}

算法思想：建立两个空链表LA，LB，逐步遍历单链表LC奇数部分链接到LA的后面，偶数部分链接到LB的后面，对链表B的部分采用头插法完成逆置，完成LC的拆分。

具体实现代码：

LinkList divide_L(LinkList& La) {
	LinkList Lb = (LinkList)malloc(sizeof(LNode));
	Lb->next = NULL;
	LNode* p = La->next, * pre=La;
	LNode* rb = Lb;
	int i = 0;
	while (p!=NULL)
	{	
		i++;
		if (i % 2 == 0) {
			pre->next = p->next;
			p->next = rb->next;
			rb->next = p;
			p = pre->next;
		}
		else
		{
			pre = p;
			p = p->next;
		}
	}
	printf("改变后的链表B");
	while (Lb->next!=NULL)
	{
		printf("%d->", Lb->next->data);
		Lb->next = Lb->next->next;
	}
	printf("\n改变后的链表A:");
	while (La->next != NULL)
	{
		printf("%d->", La->next->data);
		La->next = La->next->next;
	}
	return La;
}

运行结果截图：