数据结构代码题-----Day03

数据结构代码题目总结

题目01

试编写带头结点的单链表L中删除一个最小值节点的高效算法，（假设最小值是唯一的）

思路分析：

1. 首先是需要找到最小值
2. 删除最小值

如何找到最小值呢

根据上图图片，这里设置了p指针作为头节点后的指针，同时根据总结需要对其进行设计

1. 所需的指针数量
2. 扫描指针一个
3. minP最小值指针一个
4. 前驱指针一个pre
5. 最小值前驱一个preMinp

查找最小值节点实现思路

1. 指针P遍历链表，
2. 在遍历过程中若P->data 小于 MinP->data的数据，设置minp为当前的p节点
3. 若扫描的当前节点不是最小值的节点
4. 前驱指针向后移，当前指针向后移

其实现的查找代码大致如下：

	//查找代码
	if(p->data < minp->data){
		minp = p;
	}
		pre = p;//前驱指针和当前指针向后移动
		p = p->next;
	//若不是最小值

查找完毕后看如何删除

如何删除最小值的节点？

算法思路图解：

图解为：
要想在链表中删除一个节点

1. 最小值节点前驱的后继指向当前删除节点的后继
2. free释放当前节点的内存

其题目完整实现代码如下：

//因为要操作链表所以必要加&符号
//结构体
typedef struct LNode{
	int data;
	struct LNode *  next;
};

ListLink Delete_min(ListList &L){
	//初始化节点
	LNode * pre = L;
	LNode * p = pre->next;//指向头节点的下一个节点
	LNode * minp = p;//min初始化
	LNode * minpre = pre;//初始化前驱

	while(p != null){
		//核心代码
		if(p->data < minp->data){
			minp = p;
			minpre = pre;
		}else{
			pre = p;
			p = p->next;
		}//不是当前的最小值
		//删除查找的节点
		//已经找到最小值的前驱
	}
		minpre->next = minp->next;
		free(minp);
	
}

题目02

头插法建立单链表

头插法建立单链表的实现是贴着根节点的下一个节点设计的
其核心代码为：

s = (LNode*)malloc(sizeof(LNode));
		s->data = x;//赋值
		//核心代码
		s->next = L->next;
		L->next = s;

完整代码如下：

//头插法建立单链表
Listlink List_HeadInsert(Linklist &L){
	//设置操作指针
	LNode * s;
	int x;
	//分配内存
	L = (Linklist)malloc(sizeof(LNode));
	scanf("%d",&x);//输出数据
	while(x!=-1){
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;//赋值
		//核心代码
		s->next = L->next;
		L->next = s;
	}
	return L;
}

头插法建立单链表性质

1. 顺序序列相反
2. 适用于链表的转置操作

尾插入法建立单链表

1、序列顺序相等
其核心主要是指针始终指向的是最后一个节点

尾插法建立单链表的实现代码如下：

//尾插法建立单链表
Listlink List_TailInsert(Linklist &L){
	LNode * s;
	L = (Linklist)malloc(sizeof(LNode));
	LNode * r = L;//指向根节点
	int x;
	scanf("%d",&x);//赋值
	while(x != -1){
		//核心代码
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
	}
	//在最后添加后需要对为节点设置为null
	r->next = null;//设置r的下一个为null
}

题目04 头插法应用

完成单链表原地逆置

实现的思路顺序图解：

这里先粘贴代码：

//核心代码
//单链表逆置
Linklist ReverseLinklist(Linklist &L){
	LNode *p = L->next;
	//保存后继节点
	LNode * r;
	//头节点断开
	L->next = null;

	while(p != null){
		r = p->next;//保存p的后继节点
		p->next = L->next;//这里的l-》next代笔null
		L->next = p;
		p = r;//重新赋值
	}
	return L;

}

算法执行过程图解
1、初始化逆置指针

LNode *p = L->next;
	//保存后继节点
	LNode * r;

2、头节点断开代码执行

//头节点断开
	L->next = null;

图解

3、核心代码处理

	while(p != null){
		r = p->next;//保存p的后继节点
		p->next = L->next;//这里的l-》next代笔null
		L->next = p;
		p = r;//重新赋值
	}

其第一次循环得到的过程图为

整理得到的逆置第一个节点的过程图如下：

实现的过程解释

1. 首先是将r指针保存好p的后继指针你，防止丢失断链
2. 其次是通过p节点的后继指向根节点的后继为null
3. 根节点进行p节点的连接
4. 逆置完毕，让p重新赋值给r
5. 进行下一轮的遍历逆置
6. 当p为null时循环结束，逆置完成

==================================================

注：

个人代码问题或需要程序编写辅导服务等问题请加闲鱼【代码无bug】
或点击下面链接跳转闲鱼进行咨询

闲鱼链接