数据结构代码题----day08（链表结构最终章节）

数据结构代码题

题目01

假定带有头结点的单链表保存有两个单词，设str1，str2分别指向头节点，设计一个时间上尽可能高效的算法，找出由str1和str2所指向两个链表共同后缀的起始位置。

题目分析图

结合图示分析，这里题目的意思是要找到两个单链表存储单词的公共的第一个结点，因此类似于之前学到的如何求两个单链表的公共结点的问题，在前面的文章中已经讲到，下面是链接：
求单链表公共结点文章–第二题

这里采用最为基础的设计分析方式，即采用暴力法和间距的寻找方式进行设计。基于已经阅读过前面的文章，这里我们直接给出完整代码(看完之前的文章，这道题目很简单了就)
强调一点

题目的要求中因为要对时间尽可能的高效，所以选择编写代码的时候要考虑时间复杂度的问题，
一般来讲，时间尽可能更高效的实现方式有：

1. 只遍历一次链表
2. 用空间来换时间—开辟一个新的数组或其他的数据结构

//设置结构体
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode, *LinkList;

//获取带头节点的单链表的长度函数
int GetLength(LNode* head){
	LNode * p = head->next;
	int len = 0;
	while(p!=NULL){
		len++;
		p = p->next;
	}
	return len;
}

//主函数
LNode* GetConmmonLNode(LinkList &str1,LinkList &str2){
	int str1_length = GetLength(str1);
	int str2_length = GetLength(str2);
	LNode *p,*q;
	int k = 0;//间隔
	//首先进行间隔判断
	if(str1_length > str2_length){
		k = str1_length-str2_length;
		p = str1->next;//p始终指向的是长链表
		q = str2->next;
	}else{
		k = str2_length-str1_length;
		p = str2->next;//p始终指向的是长链表
		q = str1->next;
	}

	//进行长度调整
	while(k--){
		p = p->next;
	}

	//现在p和q在同一个起点
	while(p!=NULL){
		if(p==q){
			return p;
		}else{
			p = p->next;//同时后移
			q = q->next;
		}
	}
	return NULL;//没有找到返回NULL
}

题目02

题目分析

1、根据题目要求先给出链表的结构体

//设置结构体
typedef struct LNode{
	ElemType data;
	struct LNode *link;
}LNode, *LinkList;

2、对节点的绝对值的表示

这里采用三目运算符进行表示，如下代码：

int m  = p->data>0 ? p->data : -(p->data)

解释：

1. 设置一个m变量存储数值；
2. 同时若p->data大于0，那么绝对值就是他本身；
3. 若p->data小于0，那么绝对值则是它的负数。

下面是解题思路

1. 时间复杂度高效的算法，这里采用空间换时间的规则进行设计；
2. 开辟一个一维数组；
3. 对其中扫描到的数据进行记录；
4. 记录方式为遍历的data域的数值为多少，就在一维数组的相应的下标处所对应的数值置1。
5. 后期若再扫描到该绝对值的相等的结点，直接进行删除。

下面是算法设计思路图解：

结合以上的思路进行代码的编写，其核心代码如下：

	//开始遍历单链表
	while(p!= NULL){
		int m = p->data>0 ? p->data :-(p->data);//进行取值绝对值
		if(C.data[m]==0){//说明该位置处的数值还没有访问
			//先置1
			C.data[m] = 1;
			//进行往后遍历
			pre = p;
			p = p->next;
		}else{//若访问的结点之前已经访问过，
			//执行删除
			p->next = pre->next;
			free(p);
			p = pre->next;//重置p的指向结点，应该在删除的结点下一个结点继续进行遍历
		}
	}

完整代码如下：

void Find_Delete_SameLNode(LinkList &head,int n){
	//初始化准备结点
	LNode * p = head->next;
	LNode * pre = head;
	//开辟一个数组
	C = (int)malloc(sizeof(int*))(n+1);//需要开辟n+1个空间
	//初始化数组元素值为0
	for(int i = 0; i < n+1;i++){
		C.data[i] = 0;
	}
	//开始遍历单链表
	while(p!= NULL){
		int m = p->data>0 ? p->data :-(p->data);//进行取值绝对值
		//注，这个地方可以换成api调用abs函数
		if(C.data[m]==0){//说明该位置处的数值还没有访问
			//先置1
			C.data[m] = 1;
			//进行往后遍历
			pre = p;
			p = p->next;
		}else{//若访问的结点之前已经访问过，
			//执行删除
			//前驱节点的next指向当前删除节点的next
			pre->next = p->next;
			free(p);
			p = pre->next;//重置p的指向结点，应该在删除的结点下一个结点继续进行遍历
		}
	}
	free(C);//最后释放全部结点
}

题目03

设线性表L=(a1,a2,a3…an-2,an-1,an)，采用头节点的单链表保存，其结构体代码如下，请设计一个空间复杂度为O(1)，且时间复杂度尽可能高效的算法，重新排列L中的各个结点，得到L =(a1,an,a2,an-1,a3,an-2…)
结构体代码如下：

//设置结构体
typedef struct node{
	int data;//数据域
	struct LNode *next;//指针域
}NODE;

这里以a1-----------a6的例子图进行分析：

结合以上的图解分析，对于其中存在的转换如何进行能够转换为下方的结点的布局。
这里引出之前文章中的一个题目，进行比较一下：
单链表的结点的结点的分开排列

注意：这个题目与上面链接中的题目不同，采用奇数结点尾插法和偶数结点头插法的方式实现是不合逻辑的，因为题目要求便是空间复杂度为0(1）代表不能再次申请一个存储数组了

那么如何实现这个转化呢，这里我们尝试采用最为基础的方法进行实现
-------------采用逆置+“伪头插法的方式进行设计”-----------------------
操作图解如下：

结合以上的单链表的操作，我们一步步的进行分布进行实现设计：

1、第一步是找到链表的中间结点
实现思路如下图所示：

思路：

1. 采用一个快慢指针
2. 快指针一次走两步
3. 慢指针一次走一步
4. 快指针到终点，慢指针到中点。

其实现代码如下：

while(q->next != NULL){//快指针到终点
	p=p->next;//慢指针走一步
	q = q->next;
	if(q->next!=NULL){
		q = q->next;//快指针走两步
	}
}

2、第二步是对后半部分结点逆置
其实现的依据便是最为熟悉的头插法，其实现图解如下：

其实现的步骤依然与头插法相同，

1. 设置头插的第一个结点q
2. 断链-----p的next指向nulll
3. 保存q的下一个结点r
4. 进行头插
5. 结束后重置q进行q= r；

结合以上的步骤分析，得到的逆置代码：

	q = p->next;
	p->next = NULL;
	while(q！=NULL){
		r = q->next;//保存
		q->next = p->next;
		p->next = q;//头插法
		q  = r;//重置q
	}

3、第三步是插入逆置的结点
实现图解如下：

插入的实质也是遵循头插法的，但是这个跟头插法不一样，下面看代码：

	s = L->next;
	q = p->next;//重置q
	p->next = NULL;
	while(q!= NULL){
		r = q->next;//保存---
		q->next = s->next;
		s->next = q;//插入结点
		/**
		 * 
		 * 注意！！！！！！
		 */
		s = q->next;//s要先置为插入结点的下一个
		q = r;//重置q
	}

分析：

1. 删除前先设置好相关的指针
2. p指针断链
3. r指针保存结点
4. 进行插入
5. 最重要的一点是，这里要先让s指向q的next结点，方便下一轮的插入
6. 重置q操作

完整代码如下：

void ChangeList(LNode *L){
	LNode * p,*q,*r,*s;
	q = p = L;//走的起点在头节点
	//该种中间节点的找寻方式，在链表长度为计数和偶数都适合(有头节点)
	while(q->next != NULL){//快指针到终点
		p=p->next;//慢指针走一步
		q = q->next;
		if(q->next!=NULL){
			q = q->next;//快指针走两步
		}
	}

	//进行逆置
	q = p->next;
	p->next = NULL;
	while(q！=NULL){
		r = q->next;//保存
		q->next = p->next;
		p->next = q;//头插法
		q  = r;//重置q
	}
	//进行合并插入
	s = L->next;
	q = p->next;//重置q
	p->next = NULL;
	while(q!= NULL){
		r = q->next;//保存---
		q->next = s->next;
		s->next = q;//插入结点
		/**
		 * 
		 * 注意！！！！！！
	 	*/
		s = q->next;//s要先置为插入结点的下一个
		q = r;//重置q
	}
}

考研算法学习之路！！！！！！！加油

注：

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

闲鱼链接