C++\C 链表相关问题的思考和总结

最新推荐文章于 2024-03-07 19:02:15 发布
最新推荐文章于 2024-03-07 19:02:15 发布
阅读量243 收藏 1
点赞数 1
分类专栏： 算法学习 文章标签： 链表 指针 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46338206/article/details/107733260
版权

链表相关问题

如何完成链表的逆序

问题一：已知链表头节点指针head，将链表逆序。（不可申请额外空间）

逆序就好比人们排队时的变换阵型的过程，比如，原本已经排好的队伍，我想要把排头的放在最后，排尾的放到前面来，完成队伍的翻转，这个过程就是把每次排头的人放在新队伍所有人的前面，从而做到原队伍的翻转。

上述的过程主要运用的是倒插法来解决问题，思路如下：

新建一个同类型的空指针new_head，在循环的操作下执行以下操作：一个原链表的头指针的下一节点next，将头指针head连接到空指针new_head的前面，new_head向前挪一格，即指向head所指向的地址，head指向next，也就是剩余原链表的头节点；直至头节点为空而停止操作。

代码如下：

#include<iostream>
#define _CRT_SECURE_NO_WARNINGS

using namespace std;

struct ListNode {
	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(NULL) {}
};

ListNode* reverseList(ListNode* head) {
	ListNode *new_head = NULL;
	while(head){
		ListNode *next = head->next;
		head->next = new_head;
		new_head = head;
		head = next;
	}
	return new_head;
}

int main(){	
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	ListNode *head = &a;
	printf("Before reverse:\n");
	while(head){
		printf("%d\n", head->val);
		head = head->next;
	}
	head = reverseList(&a);
	printf("After reverse:\n");
	while(head){
		printf("%d\n", head->val);
		head = head->next;
	}
	return 0;
}

问题二：选择性的逆序m到n的链表[1<=m<=n<=链表长度]（进阶）

在上一个问题的基础上施加更多的要求，考验代码灵活应变的能力。

对于原来的链表，我要找到第m个节点和第n个节点，将他们逆序之后再连接回链表中，其中我们就要思考到关键性的问题——①当我们完成了m到n的节点逆序之后，我们该如何找到第m-1个节点和第n+1个节点，使得逆序的链表链接回原链表？②遍历到第m个节点之后，继续遍历，如何防止第m个节点位置的丢失？

这时，就涉及到对于关键位置的节点地址保存的问题，例如，建立pre_head指针在遍历到第m个节点时，指向第m-1个节点，同时建立指针m_Node指向第m个指针，在遍历到第n个节点时，建立指针new_head指向第n个节点，next指针将做为下一连接的节点。

代码如下：

#include <stdio.h>

struct ListNode {
	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        int change_len = n - m + 1;
        ListNode *pre_head = NULL;
        ListNode *result = head;
        while(head && --m){
        	pre_head = head;
        	head = head->next;
        }
        ListNode *modify_list_tail = head;
        
        ListNode *new_head = NULL;
		while(head && change_len){
			ListNode *next = head->next;
			head->next = new_head;
			new_head = head;
			head = next;
			change_len--;
		}
		modify_list_tail->next = head;
		
		if (pre_head){
			pre_head->next = new_head;
		}
		else{
			result = new_head;
		}
		return result;
    }
};

int main(){	
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	Solution solve;
	ListNode *head = solve.reverseBetween(&a, 2, 4);	
	while(head){
		printf("%d ", head->val);
		head = head->next;
	}
	return 0;
}

结果为：
1 4 3 5 2

链表的交点问题

问题一：两个链表之间的交点

思路一：我将其中一个链表的指针都放入到一个vector的容器中，循环headB指针，通过find函数，说明headB的指针是否存在于这个容器中，当存在，返回指针，不存在，返回NULL。(有存储空间上的使用)

思路二：先计算出两个链表的长度，把较长的链表指针头走到与另一链表相同长度的位置，再同时向后遍历，当两个指针同时指向同一地址时，说明有交点，返回指针，不存在交点，返回NULL。（无存储空间上的使用）
如图所示：

所以对比上述两种方法，显然思路二更加优良，这里提供思路二的解题方法。

代码如下：

#include <stdio.h>

struct ListNode {
	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(NULL) {}
};

int get_list_length(ListNode *head){
	int len = 0;
	while(head){
		len++;
		head = head->next;
	}
	return len;
}

ListNode *forward_long_list(int long_len, 
				int short_len, ListNode *head){
	int delta = long_len - short_len;
	while(head && delta){
		head = head->next;
		delta--;
	}
	return head;
}

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
   		int list_A_len = get_list_length(headA);
   		int list_B_len = get_list_length(headB);   		
   		if (list_A_len > list_B_len){
   			headA = forward_long_list(list_A_len, list_B_len, headA);
	   	}
	   	else{
	   		headB = forward_long_list(list_B_len, list_A_len, headB);
	   	}   		
        while(headA && headB){
        	if (headA == headB){
	        	return headA;
	        }
	        headA = headA->next;
	        headB = headB->next;
        }
        return NULL;
    }
};

int main(){
	ListNode a1(1);
	ListNode a2(2);
	ListNode b1(3);
	ListNode b2(4);
	ListNode b3(5);
	ListNode c1(6);
	ListNode c2(7);
	ListNode c3(8);
	a1.next = &a2;
	a2.next = &c1;
	c1.next = &c2;
	c2.next = &c3;
	b1.next = &b2;
	b2.next = &b3;
	b3.next = &c1;	
	Solution solve;
	ListNode *result = solve.getIntersectionNode(&a1, &b1);
	printf("%d\n", result->val);
	return 0;
}

问题二：单个链表的交点（成环）

首先需要了解这样的一个有环链表具有什么样的特点：①最后没有NULL 进行结尾；②存在成环时的首节点（即环交点）。

思路一：在寻找环交点的过程也可以仿照上一问题的思路一，将链表从头节点进行遍历，建立一个存放链表指针的vector容器，每遍历一个指针就判断指针是否存在于容器中，在存入容器中，当链表指针成功将链表中的环遍历一遍，进行下一次时，首指针（即成环首交点处的地址）已存在容器中，则返回该指针，否则不存在环，返回NULL。（有存储空间的使用）

思路二：一个经典的方法：快慢指针法；我们建立两种指针，一次走两步的fast指针和一次走一步的slow指针，当fast指针与slow指针相遇时，从头指针head和相遇时的节点指针meet到环交点指针的距离相等。（无存储空间的使用）

a：头节点到环交点的距离
b：环交点到相遇节点的距离
c：相遇节点到换节点的距离

（字有点凌乱，见笑了）

代码如下：

#include <stdio.h>

struct ListNode {
	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
    	ListNode *fast = head;
    	ListNode *slow = head;
    	ListNode *meet = NULL;
    	while(fast){
    		slow = slow->next;
    		fast = fast->next;
    		if (!fast){
		    	return NULL;
		    }
		    fast = fast->next;
		    if (fast == slow){
    			meet = fast;
    			break;
    		}
	    }
	    if (meet == NULL){
    		return NULL;
    	}
    	while(head && meet){
	    	if (head == meet){
	    		return head;
	    	}
	    	head = head->next;
	    	meet = meet->next;
	    }
        return NULL;
    }
};

int main(){
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	ListNode f(6);
	ListNode g(7);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	e.next = &f;
	f.next = &g;
	g.next = &c;
	Solution solve;
	ListNode *node = solve.detectCycle(&a);
	if (node){
		printf("%d\n", node->val);
	}
	else{
		printf("NULL\n");
	}
	return 0;
}

链表的深拷贝

题目讲解：一个链表中，有两个链接链表的节点，一个next，按链表顺序链接链表，另一个random，随机链接链表的节点（包括自身）求这个链表的深拷贝
简单形式，如图所示：
深拷贝的连接形式
这道题，我打算改变原有的罗列顺序，先将代码放出，后将解题的思路梳理出来，希望道友们能懂得看似复杂的代码背后，是一个简单、浅显的道理！
代码如下：

#include <stdio.h>
		
struct RandomListNode {
	int label;
	RandomListNode *next, *random;
	RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
};

#include <map>
#include <vector>

class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
    	std::map<RandomListNode *, int> node_map;
    	std::vector<RandomListNode *> node_vec;
    	RandomListNode *ptr = head;
    	int i = 0;
    	while (ptr){
	    	node_vec.push_back(new RandomListNode(ptr->label));
	    	node_map[ptr] = i;
	    	ptr = ptr->next;
	    	i++;
	    }
	    node_vec.push_back(0);
	    ptr = head;
	    i = 0;
	    while(ptr){
    		node_vec[i]->next = node_vec[i+1];
    		if (ptr->random){
    			int id = node_map[ptr->random];
		    	node_vec[i]->random = node_vec[id];
		    }
    		ptr = ptr->next;
    		i++;
    	}
    	return node_vec[0];
    }
};

int main(){
	RandomListNode a(1);
	RandomListNode b(2);
	RandomListNode c(3);
	RandomListNode d(4);
	RandomListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;	
	a.random = &c;
	b.random = &d;
	c.random = &c;
	e.random = &d;	
	Solution solve;
	RandomListNode *head = solve.copyRandomList(&a);	
	while(head){
		printf("label = %d ", head->label);
		if (head->random){
			printf("rand = %d\n", head->random->label);
		}
		else{
			printf("rand = NULL\n");
		}
		head = head->next;
	}
	return 0;

看完上述的过程，道友们是否懂得了这个代码所要传达的主体思路了呢？

那么接下来，由我来梳理一下这个主题过程：
对于这样凌乱看似毫无章法的链表，首先要做的就是将其所包含的信息给梳理出来，比如这里就通过一个node_map容器储存链表指针和节点号的方式，梳理出了由next节点排序出的链表格式，第二个链表则为遍历地存储新链表节点，之后通过梳理出的node_map关系，重新把node_vec容器中的节点连接起来，形成新的链表进行输出，从而完成链表的深拷贝。
如图所示：(节点地址与节点序号对应)
思路图

致谢

本章知识点和思路由小象学院相关视频提供，由本人学习并梳理得出，希望自己加深记忆的同时，也能给大家提供更多有关于链表的知识点，谢谢支持！

章明狼
关注
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 8万+
C/C++学习路线总结与分享
【课程设计｜C++】实现两个链表的合并
海到无边天作岸 山登绝顶我为峰
06-15 2499
（1）建立两个链表A和B，链表元素个数分别为m和n个。（2）假设元素分别为(x1,x2,…,xm)，和(y1,y2,…,yn)。把它们合并成一个线性表C： 当m>=n时，C=x1,y1,x2,y2,…,xn,yn,…,xm 当n>m时， C=y1,x1,y2,x2,…,ym,xm,…,yn；（3）输出线性表C。（4）用直接插入排序法对C进行升序排序，生成链表D，并输出链表D。（1） A表（30，41，15，12，56，80） B表（23，56，78，23，12，33，79，90，55）（2） A表（30，4
c语言编写的链表逆置的总结
10-01
三种不同的方法，挺不错的！ #include<stdio.h> #include<stdlib.h> #include<string.h> #define N 100 typedef struct SList { char data[N]; //字符数组 struct SList *next; //定义链表头指针 }SList,*ListPointer; /*typedef struct List { SList *head; }List,* ListPointer; */ void initList(ListPointer &lp) { lp=(SList *)malloc(sizeof(SList));//初始化链表 lp->next=lp; //链表的头指针指向本身，实现链表循环 } void output(ListPointer lp) // 自定义输出函数 { SList *ep; ep=lp; while(ep->next!=lp) //判定条件 当指针重新指向头指针输出结束 { ep=ep->next; printf("%s ",ep->data); } } void revert(ListPointer lp) // 链表的逆置 { SList *p,*q; p=lp;q=NULL;lp=NULL; while(p) { q=p->next; p->next=lp; lp=p; p=q; } /*方法二 SList *p,*q,*end; p=lp->next; q=p->next; end=p; while(q!=lp) { lp->next=q; q=q->next; lp->next->next=p; p=lp->next; } end->next=lp; */ } void add_char(char *p,ListPointer lp) //将输入的字符传递给链表 { SList * ep; ep=lp; while(ep->next!=lp) //判定条件 当指针重新指向头指针输出结束 { ep=ep->next; } ep->next=(SList *)malloc(sizeof(SList)); //开辟空间存储 strcpy(ep->next->data,p); //字符的传递 ep->next->next=lp; } void main() { ListPointer L; char str[N]; initList(L); printf("输入#以结束\n");//确定输入终止条件 while(1) { scanf("%s",str); if(*str=='#') //判定条件 { break; } add_char(str,L); } printf("初始序列为:"); output(L); printf("\n"); revert(L); printf("逆置后为:"); output(L); printf("\n"); }
链表基础问题（C++）
weixin_42067873的博客
01-07 728
一、链表反转（逆序） 设置一个new_head代表反转后的头节点 #include <stdio.h> struct ListNode{ int val; ListNode *next; ListNode(int x):val(x), next(NULL){} }; class Solution{ public: ListNode* reverseList(ListNode* head){ ListNode* new_head = NULL; //指向新链表头节点的指针
因写链表产生的感想和思考（什么是总结）
lushi1314的博客
10-15 314
写链表之前的感想： 写链表的意义： 因为后期学习到c++之类的都有自己写好的容器（包含链表），比自己写的好太多了，因此觉得没必要自己花时间熟练链表的编写。但是逐渐了解了自己想法的错误。 第一个意义，觉得是自己当前写链表的主要原因，因为身边同学大四找工作，公司招人的时候大多问的是数据结构方面的，虽然不一定是链表，但是让我了解到数据结构的重要性，因此也让我重新整理自己数据结构的知识点。 ...
C语言——链表相关总结
gaoshanyangzhi_1999的博客
06-02 512
一、链表创建 链表头插： Node * creat_h () { Node * pHead,* pNew; pHead=(Node*)malloc(sizeof(Node)); pHead-&amp;gt;next=NULL; printf(&quot;请输入正整数：&quot;); pNew=(Node*)malloc(sizeof(Node)); sc...
C语言链表 应用总结
fengweibo112的博客
03-13 1636
前言 每次面试的时候，面试官都会问你，会链表不（显得很高逼格）？掌握链表的创建、插入、删除、修改、清空。你会发现，其实链表就那么回事。 几个概述 链表可以动态分配内存。 链表一般有一个头指针，一般以head来表示，存放的是一个地址。 链表节点：数据+指向next节点的指针； 链表节点分为两类：头节点、一般节点。 创建链表 1.创建链表结构体 typedef struct LinkList { ...
链表面试题总结 C/C++
Dev-L的博客
11-02 2245
数据结构和算法，是我们程序设计最重要的两大元素，可以说，我们的编程，都是在选择和设计合适的数据结构来存放数据，然后再用合适的算法来处理这些数据。       在面试中，最经常被提及的就是链表，因为它简单，但又因为需要对指针进行操作，凡是涉及到指针的，都需要我们具有良好的编程基础才能确保代码没有任何错误。       链表是一种动态的数据结构，因为在创建链表时，我们不需要知道链表的长度，
c++链表反转/逆置的思考与解析
一只懒虫的博客
04-04 1500
文章目录1.代码示例2.图文解释3.思考总结 1.代码示例 在Clion，用C14标准编译运行通过 采用的是有头节点的链表 #include <iostream> using namespace std; typedef struct ListNode { ListNode* next; int val; ListNode():val(0),next(NU...
c语言链表学生成绩管理系统
最新发布
weixin_64055968的博客
03-07 2295
本次设计让我更加熟悉了链表的概念和操作。链表作为一种常用的数据结构，在实际项目中应用广泛。通过设计链表来管理学生信息，我加深了对链表结构的理解，包括节点的插入、删除、遍历等操作，这对我今后在开发其他项目时也大有裨益。设计学生成绩管理系统让我更加熟悉了文件操作。在本次设计中，我使用文件来保存学生信息，实现了学生信息的持久化存储。这让我对文件操作的函数和用法有了更深入的了解，也锻炼了我处理文件输入输出的能力。
C++链表经典问题（指针）
weixin_45758146的博客
06-22 437
1、可以同时使用多个指针。 需要同时跟踪多个节点，要记住跟踪哪些节点，并可以自由使用几个不同的节点指针来同时跟踪这些节点。 同时使用多个节点，取适当的名称，以便调试代码。 2、需要跟踪当前节点的前一个节点。 无法追溯到链表的前一个节点，因此不仅要存储当前节点，还要存储前一个节点。双链表不同。 3、双链表：多一个引用字段，prev，能够知道当前节点 的前一个节点。 4、双链表添加节点cur： 连接cur 与 （指向）prev和 next，再cur 与（被指向） prev和 next重新连接。 5、双链表删除
关于c++链表的一些感想
sx1989827的专栏
01-27 1604
     最近学嵌入式开发,c语言是基础,貌似c++也快挤进这个行列了,当然无论是c还是c++,数据结构是少不了的,所以我最近一直在狂补数据结构,关于链表这一块,貌似是数据结构的根基,所以我也下了一番苦功,以下是关于链表的一段代码,分为链表的创建,翻转与排序,有什么写 的不好的地方,还望高手见笑.#includeusing namespace std;struct s{int a;
C++链表总结
weixin_55850954的博客
11-22 1035
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录1.单向链表2.双向链表3.循环链表4.静态链表5.测试代码 1.单向链表 头节点不存储信息，尾节点存储信息，便于后续尾插 //单链表 class List { private: struct Node { int value; Node* next; }; //头节点,不存储信息 Node* head; //尾结点,便于后续尾插 Node* tail; //数量 int size; public:
C++ 链表 总结
志汉天涯~！~Day Day Up~
08-20 147
链表的基本操作： 链表的建立、删除；元素的插入、删除、查找。 顺序表 虽然能够随机存取表中的数据元素，但以下缺点是不可避免的。 需预先开辟一片连续的存储空间，对存储空间的要求比较苛刻。 在顺序表上得插入、删除操作时，一般设计元素的前后移动，影响程序的运行效率。 线性链表 可以克服以上的不足，但线性链表要占用较多的存储空间，不过在执行插入，删除时不需要移动元素。 ...
浅谈C++单链表（基础篇）
wcqqq的博客
04-13 1139
今天浅谈一下链表，（感谢zz大佬的帮助！！！orz） 怎么说呢？链表我觉得挺像链式向前星存图捏 众所周知，链表相对于数组的优越性在于，它可以实现灵活的内存动态管理，并且节点的数量可以扩充，删除插入一个元素容易。接下来进入今天的正题。 实现链表的增删改查！！！ 如图所示，所谓链表，就是由若干个节点组成，而每个节点就是由数据域和指针域组成。每个指针域指向下一个的首元节点 接下来，我来介绍两种方法来构造链表并且遍历整个链表。 I：构造链表并且遍历 1：构造函数法 #include<
c++链表问题汇总(代码及解析)
祥瑞的技术博客
09-01 1771
目录 一、链表与指针 1.1 单向双向表 1.2 数组指针 1.3 链表的合并 二、链表应用汇总 2.1 链表中的值倒序 2.2 链表的倒数第k个节点 2.3 反转链表 2.4 链表的公共节点 2.5 链表环的入口节点 三、复杂链表的复制 3.1 题干 3.2 思路及注意事项 3.3 正确答案 3.4 错误代码找错 四、二叉树转为双向链表 相应oj链接： htt...
初学C++链表的形参实参心得体会
lavebo12的博客
02-08 802
都知道C++定义一个单链表如下 // 单链表 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 今天偶然碰到一个问题 如下函数 void next(Node *head) { head=head->next; } 当时试了下在主函数调用时，发现实参头节点并没有移动到下一个节点的内存位置，但是在主函数直接
有关链表的思考
初级码农
09-25 342
1.head如何来定义的，tail如何来定义的。head->node1->node2..........head可以看成等于第一个node0->next;node1->next就是保存下一个的节点node的首地址的指针。单链表只能从0往N进行遍历。第一是定义一个结构体指针，然后用NULL来初始化这个指针防止其成为悬挂指针，把第一个节点的首地址赋给这个head.最后一个结构体的nodeN->next 用NULL来初始化这个指针防止其成为悬挂指针。遍历的算法 p(N)=P(N-1)->next;
链表问题大总结---------（面试官最喜欢的问题）
zzhfighting的博客
08-21 500
某本书上面说了，链表这个东西，实际用的并不多，但是可以提供很好的考察面试者编程技巧和思维能力的素材。这里总结一下，见过的面试题和对应的候选解法。 题一、 给定单链表，检测是否有环。     使用两个指针p1,p2从链表头开始遍历，p1每次前进一步，p2每次前进两步。如果p2到达链表尾部，说明无环，否则p1、p2必然会在某个时刻相遇(p1==p2)，从而检测到链表中有环。 http://ost
C++链表实践：模块化程序设计训练
课程目标包括增强对C语言及数据结构的理解，提升分析、设计和解决问题的能力，以及提高程序设计与调试、技术文档撰写的能力。评分标准包括考勤、编程实现和设计报告，强调原创性和规范化编程，如模块化结构和锯齿型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值