《面试算法 LeetCode 刷题班》—— 1. 链表

最新推荐文章于 2021-07-17 23:06:24 发布
最新推荐文章于 2021-07-17 23:06:24 发布
阅读量188 收藏
点赞数
分类专栏： 高级程序设计 文章标签： 算法
原文链接：https://blog.csdn.net/Chris_zhangrx/article/details/84797591
版权

本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！

1.链表

文章目录

LeetCode 206 链表逆序 a （E）

问题描述：

已知链表头节点指针head，将链表逆序。

提交代码：

class Solution {
public:
	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;
	}
};
LeetCode 92 链表逆序 b（M）

问题描述：

已知链表头节点指针head，将链表从位置 m 到 n 逆序。

提交代码：

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;
	}
};
LeetCode 160 求两个链表的交点（E）

问题描述：

已知链表A 的头节点指针 headA,链表B 的头节点 headB, 两个链表相交，求两个链表交点对应的节点。
要求：
1.如果两个链表没有交点，则返回NULL
2.在求交点过程中，不可破坏链表的结构或者修改链表的数据域
3.确保链表A和B都没有环
4*.实现算法时间复杂度O（n），空间复杂度O（1）

算法思路1：用标准库 set 求交集

1.遍历链表A，将A中节点对应的指针（地址），插入 set
2.遍历链表B，将B中节点依次在 set 中查找，发现即为两个链表交点，未发现则返回NULL

代码实现：

class Solution {
public:
	ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
		set<ListNode*> tmp_set;
		while (headA)
		{
			tmp_set.insert(headA);
			headA = headA->next;
		}
		while (headB)
		{
			if (tmp_set.find(headB) != tmp_set.end()) {
				return headB;
			}
			else
			{
				headB = headB->next;
			}
		}
		return NULL;
	}
};

思路2： 空间复杂度O（1）

1.计算headA链表长度，计算链表B的链表长度，从而得出较长的链表多出的长度
2.将较长的链表的指针移动到和较短链表指针对齐的位置
3.headA 与 headB 同时移动，当两个指针指向同一个节点时，即找到了

代码实现：

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

class Solution {
public:
	ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
		int headA_len = get_len(headA);
		int headB_len = get_len(headB);
		if (headA_len > headB_len)
		{
			int dis = headA_len - headB_len + 1;
			while (headA && -- dis)
			{
				headA = headA->next;
			}
		}
		else if(headA_len < headB_len)
		{
			int dis = headB_len - headA_len + 1;
			while (headB && --dis)
			{
				headB = headB->next;
			}
		}
		while (headA && headB)
		{
			if (headA == headB) {
				return headA;
			}
			headA = headA->next;
			headB = headB->next;
		}
		return NULL;
	}
};
LeetCode 141 & 142 链表求环（M） （快慢指针问题）

问题描述：

141.已知链表中可能存在环，若有则返回真，否则返回假

142.已知链表中可能存在环，若有则返回环起始节点，否则返回NULL

思路1：用 set 求环起始节点

提交代码：141

class Solution {
public:
	bool hasCycle(ListNode *head) {
		set<ListNode *> tmp_set;
		while (head)
		{
			if (tmp_set.find(head) == tmp_set.end()) {
				tmp_set.insert(head);
				head = head->next;
			}
			else
			{
				return true;
			}
		}
		return false;
	}
};

提交代码：142

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
		set<ListNode *> tmp_set;
		while (head)
		{
			if (tmp_set.find(head) == tmp_set.end()) {
				tmp_set.insert(head);
				head = head->next;
			}
			else
			{
				return head;
			}
		}
		return NULL;
    }
};

思路2：快慢指针

首先设两个指针，一个slow指针每次前进1次，一个 fast 指针每次前进2次，然后当他们他们首次相遇时，从相遇点 meet 出发，和从 head 出发，速度相同，相遇时即为环的起点

class Solution {
public:
	ListNode *detectCycle(ListNode *head) {
		ListNode *slow = head;
		ListNode *fast = head;
		ListNode *meet = NULL;
		while (fast)
		{
			slow = slow->next;
			fast = fast->next;
			if (!fast)
			{
				break;
			}
			fast = fast->next;
			if (fast == slow)
			{
				meet = fast;
				break;
			}
		}
		if (meet == NULL)
		{
			return NULL;
		}
		while (head && meet)
		{
			if (head == meet) {
				return meet;
			}
			head = head->next;
			meet = meet->next;
		}
		return NULL;
	}
};
LeetCode 86 链表划分（M）

问题描述：

已知链表头指针head与数值x，将所有小于x的节点放在大于或等于x的节点前，且保持这些节点的原来的相对位置

提交代码：

class Solution {
public:
	ListNode* partition(ListNode* head, int x) {
		ListNode  less_head(0);
		ListNode  more_head(0);
		ListNode * less_ptr = &less_head;
		ListNode * more_ptr = &more_head;
		while (head)
		{
			if (head->val < x) {
				less_ptr->next = head;
				less_ptr = head;
			}
			else
			{
				more_ptr->next = head;
				more_ptr = head;
			}
			head = head->next;
		}
		less_ptr->next = more_head.next;
		more_ptr->next = NULL;
		return less_head.next;
	}
};
LeetCode 21 排序链表合并（2个）（E）

问题描述：

已知两个已排序链表头节点指针l1 与 l2，将这两个链表合并，合并后仍为有序的，返回合并后的头节点。

思路：
比较 l1 与 l2 指向的节点，将较小的节点插入到 pre 指针后，并向前移动较小的节点对应的指针。

class Solution {
public:
	ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
		ListNode tmp_node(0);
		ListNode *pre_node = &tmp_node;
		while (l1 && l2)
		{
			if (l1->val < l2->val)
			{
				pre_node->next = l1;
				l1 = l1->next;
			}
			else {
				pre_node->next = l2;
				l2 = l2->next;
			}
			pre_node = pre_node->next;
		}
		if (l1)
		{
			pre_node->next = l1;
		}

		if (l2)
		{
			pre_node->next = l2;
		}
		return tmp_node.next;
	}
};
LeetCode 23 排序链表合并（多个）（H）

问题描述：

已知K个已排序链表头节点指针，将这k个链表合并，合并后仍为有序的，返回合并后的头节点。

思路1：

按照上述方式，将k个链表按顺序合并 k-1 次, 可以通过但是效率很慢。

提交代码1:

class Solution {
public:

	ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
		ListNode tmp_node(0);
		ListNode *pre_node = &tmp_node;
		while (l1 && l2)
		{
			if (l1->val < l2->val)
			{
				pre_node->next = l1;
				l1 = l1->next;
			}
			else {
				pre_node->next = l2;
				l2 = l2->next;
			}
			pre_node = pre_node->next;
		}
		if (l1)
		{
			pre_node->next = l1;
		}
		if (l2)
		{
			pre_node->next = l2;
		}
		return tmp_node.next;
	}

	ListNode* mergeKLists(vector<ListNode*>& lists) {
		if (lists.size() == 0)
		{
			return NULL;
		}
		if (lists.size() == 1)
		{
			return lists[0];
		}
		for (int i = 0; i <= lists.size() - 2; i++)
		{
			lists[i + 1] = mergeTwoLists(lists[i], lists[i + 1]);
		}
		return lists[lists.size() - 1];
	}
};

思路2：

将 K*n 个节点放到 vector 中，再将vector排序，再将所有节点顺序相连。

提交代码2：**

bool cmp(const ListNode* A, const ListNode* B) {
		return A->val < B->val;
	}

class Solution {
public:

	ListNode* mergeKLists(vector<ListNode*>& lists) {
		vector<ListNode*> List_all;
		for (int i = 0; i < lists.size() ; i++)
		{
			while (lists[i])
			{
				List_all.push_back(lists[i]);
				lists[i] = lists[i]->next;
			}
		}
		if (List_all.size() == 0)
		{
			return NULL;
		}
		sort(List_all.begin(), List_all.end(),cmp);
		for (int i = 1; i < List_all.size(); i++)
		{
			List_all[i - 1]->next = List_all[i];
		}
		List_all[List_all.size() - 1]->next = NULL;
		return List_all[0];
	}
};

思路3：

对 k 个链进行分制，两两进行合并。

提交代码3：

class Solution {
public:
	ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
		ListNode tmp_node(0);
		ListNode *pre_node = &tmp_node;
		while (l1 && l2)
		{
			if (l1->val < l2->val)
			{
				pre_node->next = l1;
				l1 = l1->next;
			}
			else {
				pre_node->next = l2;
				l2 = l2->next;
			}
			pre_node = pre_node->next;
		}
		if (l1)
		{
			pre_node->next = l1;
		}
		if (l2)
		{
			pre_node->next = l2;
		}
		return tmp_node.next;
	}

	ListNode* mergeKLists(vector<ListNode*>& lists) {
		if (lists.size() == 0)
		{
			return NULL;
		}
		if (lists.size() == 1)
		{
			return lists[0];
		}

		int mid = lists.size() / 2;
		vector<ListNode*> sub1_lists;
		vector<ListNode*> sub2_lists;
		for (int i = 0; i < mid; i++)
		{
			sub1_lists.push_back(lists[i]);
		}
		for (int i = mid; i < lists.size(); i++)
		{
			sub2_lists.push_back(lists[i]);
		}
		ListNode *l1 = mergeKLists(sub1_lists);
		ListNode *l2 = mergeKLists(sub2_lists);
		
		return mergeTwoLists(l1, l2);
	}
};
LeetCode 138 有随机指针的链表拷贝（H）

问题描述：

已知一个复杂的链表，节点中有一个指向本链表任意某个节点的随机指针（也可以为空），求这个链表的深度拷贝。

思路：节点地址与节点序号对应

提交代码：

class Solution {
public:
	RandomListNode *copyRandomList(RandomListNode *head) {
		map<RandomListNode*, int> node_map;
		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];
	}
};
Dan Boneh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面试算法LeetCode刷题班
04-26
课程将程序员面试中常遇的算法与数据结构知识进行精简与归纳，细致入微地讲解笔试面试中的编程真题和相关...以leetcode.com、codeforces.com中的题目为例题，利用OJ刷题的方式提升学员的编码能力与解决算法面试题的能力
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
  这道题本质上和《剑指Offer》刷题笔记——面试题22. 链表中倒数第k个节点是一样的。都可以用单指针两次遍历或者双指针一次遍历解决。 2、代码实现 # Definition for singly-linked list. # class ListNode: # ...
Leetcode学习之深度优先搜索与宽度优先搜索（1）
qq_33948796的博客
06-23 632
开宗明义：本系列基于小象学院林沐老师课程《面试算法 LeetCode 刷题班》，刷题小白，旨在理解和交流，重在记录，望各位大牛指点！ Leetcode学习之深度优先搜索与宽度优先搜索（1） 文章目录1、岛屿数量（深搜、宽搜） LeetCode 200.DFSBFS2、词语阶梯a（宽搜、图、哈希表）3、词语阶梯b（路径的宽搜、图、哈希表） 1、岛屿数量（深搜、宽搜） LeetCode 20...
《面试算法 LeetCode 刷题班》——5.二叉树与图
Chris_zhangrx的博客
11-28 1179
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 5. 二叉树与图 文章目录5. 二叉树与图leetCode 113 路径之和2LeetCode 236 最近的公共祖先LeetCode 114 二叉树转链表LeetCode 199 侧面观察二叉树LeetCode 207 课程安排 leetCode 113 路径之和2 这里题目已经事先定义了...
《面试算法 LeetCode 刷题班》——10.复杂数据结构
qq_44744450的博客
07-17 218
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 9. 动态规划 文章目录 9. 动态规划LeetCode 70 爬楼梯 (E)LeetCode 198 打家劫舍 （E）LeetCode 53 最大子段和（E）LeetCode 322 找零钱（M）LeetCode 120 三角形（M）LeetCode 300 最长上升子序列LeetCode 64 最小路径和（M）LeetCode 174 地牢游戏（H） Leet.
《面试算法 LeetCode 刷题班》——4. 递归，回溯，分治
qq_44744450的博客
07-17 192
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 4. 递归，回溯，分治 文章目录 4. 递归，回溯，分治LeetCode 78 求子级（M）LeetCode 90 求子集2（M）LeetCode 40 组合数之和2（M）LeetCode 22 生成括号（M）LeetCode 51 N 皇后（H）LeetCode 315 逆序数（H） LeetCode 78 求子级（M） 给定一个不含重复数的集合，求所有不重复.
小象学院深度学习笔记2（卷积神经网络-基础）
qq_18882399的博客
07-28 704
卷积神经网络与传统神经网络区别：卷积较传统参数量减少，但是计算量却增大了，所以需要GPU的计算。 跳变的理解：loss在update时，因为batch的存在，每次选一定数量的图片计算其下降方向，会导致变化的存在。 全连接层的神经元个数：比上一层少一点，一般是最终输出层神经元个数的两到三被倍。 课程链接：https://www.bilibili.com/video/av10324235
算法模板（Java版）——leetcode刷题与复习指南.zip
最新发布
01-13
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势...
LeetCode刷题笔记——#21. 合并两个有序链表
12-22
###### leetcode 代码主体 ###### class Solution: def mergeTwoLists(self, l1, l2): if l1 is None: return l2 elif l2 is None: return l1 elif l1.val ListNode: prenode = ListNode(0)
LeetCode刷题笔记——63. 不同路径 II
12-21
1、解析   达到每一格的路径数量取决于它左边和上边的和。同时，如果这个点有障碍，那么这个点一定为0，因为到不了这个点。 2、代码实现 class Solution: def uniquePathsWithObstacles(self, obstacleGrid: List...
LeetCode全部题目和详细解答 数据结构算法 程序员面试求职必备
02-11
LeetCode全部题目和详细解答 数据结构算法 程序员面试求职必备
面试算法LeetCode刷题班—BAT面试官带你刷真题、过笔试
qq_44744450的博客
07-16 397
课程名称: 《面试算法LeetCode刷题班》 ——BAT面试官带你刷真题、过笔试 主讲老师: 林老师 BAT资深研发工程师(T7/P8级)，致力于搜索引擎及其子系统的研发、迭代与优化，数据分析与挖掘领域专家，多年担任校园招聘、社会招聘面试官，丰富的面试候选人经验。 课程简介: 掌握算法与数据结构是成为优秀程序员的必经之路，众多国内外知名互联网企业都将算法面试作为程序员招聘的重要和必需途径，只有高效应对各类题目，将知识储备转化为面试中的优秀表现，才能获得大公司的青睐。 本门课程将程序员面试中常遇的算法与数据
Leetcode刷题修炼手册
热门推荐
Machine Learning with Tutors
01-25 5万+
我的机器学习教程「美团」算法工程师带你入门机器学习 已经开始更新了，欢迎大家订阅~ 任何关于算法、编程、AI行业知识或博客内容的问题，可以随时扫码关注公众号「图灵的猫」，加入”学习小组“，沙雕博主在线答疑~此外，公众号内还有更多AI、算法、编程和大数据知识分享，以及免费的SSR节点和学习资料。其他平台（知乎/B站）也是同名「图灵的猫」，不要迷路哦~ “跟着...
LeetCode042——接雨水
清风阁
09-15 1万+
我的LeetCode代码仓：https://github.com/617076674/LeetCode 原题链接：https://leetcode-cn.com/problems/trapping-rain-water/description/ 题目描述： 知识点： 思路一：分别计算每一层能接的雨水数，再逐层累加得到结果（在LeetCode中提交会超时） 首先遍历数组得到最高的柱子的...
Leetcode 问题分类
02-25 670
http://leetcode.cloudfoundry.com/     Id Question Difficulty Freqency Data Structures Algorithms 1 Two Sum 2 5 array set sort two pointers 2 Add Two Numbers 3 4 linked li...
简单的链表OJ题
Gerald的博客
01-25 923
简单的链表面试题 1.逆置单链表 解题思路：将原链表进行头删，并对新链表进行头插。 源代码： ListNode *reverseList(ListNode *head) { if (head == NULL) return NULL; struct ListNode *new_head = NULL; struct ListNode *cur = NULL; //头删和头插 w...
Leetcode学习之链表（3）
qq_33948796的博客
04-30 178
开宗明义：本系列基于小象学院林沐老师课程《面试算法 LeetCode 刷题班》，刷题小白，旨在理解和交流，重在记录，望各位大牛指点！ Leetcode学习之链表（3） 文章目录1、链表求环 Leetcode 141.1421.1 思路①（set使用）1.2 思路②（快慢指针） 1、链表求环 Leetcode 141.142 题目来源：Leetcode 141.142 ...
leetcode刷题目录
07-12
以下是一些常见的LeetCode刷题目录： 1. 数组： - 两数之和 - 盛最多水的容器 - 移动零 - 三数之和 - 合并两个有序数组 2. 字符串： - 反转字符串 - 反转字符串中的单词 - 验证回文串 - 最长回文子串 - ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值