[数据结构]链表OJ(leetcode)

已于 2023-10-12 08:51:47 修改
阅读量391 收藏 2
点赞数 3
文章标签： 链表 数据结构
于 2023-02-23 23:49:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66767938/article/details/129179650
版权

目录

数据结构之链表OJ：：

                                     1.移除链表元素

                                     2.反转链表

                                     3.链表的中间结点

                                     4.链表中倒数第k个结点

                                     5.合并两个有序链表

                                     6.链表分割

                                     7.链表的回文结构

                                     8.相交链表

                                     9.环形链表

                                    10.环形链表II

                                    11.复制带随机指针的链表

数据结构之链表OJ：：

1.移除链表元素

//删除链表中等于给定值val的所有结点
struct ListNode
{
	int val;
	struct ListNode* next;
};
//方法一
struct ListNode* removeElements(struct ListNode* head, int val)
{
	struct ListNode* cur = head, * prev = NULL;
	while (cur != NULL)
	{
		//1.头删
		//2.非头删
		if (cur->val == val)
		{
			if (cur == head)
			{
				head = head->next;
				free(cur);
				cur = head;
			}
			else
			{
				prev->next = cur->next;
				free(cur);
				cur = prev->next;
			}
		}
		else
		{
			prev = cur;
			cur = cur->next;
		}
	}
	return head;
}
//不用二级指针的方法:返回头指针
//main函数调用方式:plist = removeElements(plist,6);
//方法二
struct ListNode* removeElements(struct ListNode* head, int val)
{
	struct ListNode* cur = head;
	struct ListNode* newhead = NULL;
	struct ListNode* tail = NULL;
	while (cur != NULL)
	{
		if (cur->val != val)
		{
			if (newhead == NULL)
			{
				newhead = cur;
				tail = newhead;
				cur = cur->next;
			}
			else
			{
				tail->next = cur;
				cur = cur->next;
				tail = tail->next;
			}
		}
		else
		{
			struct ListNode* del = cur;
			cur = cur->next;
			free(del);
		}
	}
	if (tail != NULL)
	{
		tail->next = NULL;
	}
	return newhead;
}
//方法三:
struct ListNode* removeElements(struct ListNode* head, int val)
{
	struct ListNode* cur = head;
	struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* tail = guard;
	while (cur != NULL)
	{
		if (cur->val != val)
		{
			tail->next = cur;
			tail = tail->next;
			cur = cur->next;
		}
		else
		{
			struct ListNode* del = cur;
			cur = cur->next;
			free(del);
		}
	}
	//最后结点是val 就会出现此问题
	if (tail != NULL)
	{
		tail->next = NULL;
	}
	head = guard->next;
	free(guard);
	return head;
}
//替代我们之前实现的二级指针
//1.返回新的链表头 2.设计为带哨兵位

2.反转链表

 

//反转链表
//方法一:取结点头插到新链表
struct ListNode* reverseList(struct ListNode* head)
{
	struct ListNode* cur = head;
	struct ListNode* newhead = NULL;
	while (cur)
	{
		struct ListNode* next = cur->next;
		cur->next = newhead;
		newhead = cur;
		cur = next;
	}
	return newhead;
}
//方法二:翻转链表方向
struct ListNode* reverseList(struct ListNode* head)
{
	struct ListNode* prev = NULL;
	struct ListNode* cur = head;
	struct ListNode* next = NULL;
	while (cur)
	{
		next = cur->next;
		cur->next = prev;
		prev = cur;
		cur = next;
	}
	return prev;
}

3.链表的中间结点

//方法一:
struct ListNode* middleNode(struct ListNode* head)
{
	struct ListNode* slow = head;
	struct ListNode* fast = head;
	while (fast && fast->next)
	{
		slow = slow->next;
		fast = fast->next->next;
	}
	return slow;
}
//方法二:
struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode* cur1 = head;
    int num = 0;
    int mid = 0;
    while (cur1 != NULL)
    {
        num++;
        cur1 = cur1->next;
    }
    mid = num / 2 + 1;
    cur1 = head;
    for (int i = 1; i < mid; i++)
    {
        cur1 = cur1->next;
    }
    return cur1;
}

4.链表中倒数第k个结点

 

//方法一:
struct ListNode* FindKthToTail(struct ListNode* pListHead, unsigned int k) 
{
	
	struct ListNode* cur = pListHead;
    int n = 0;
    while (cur)
    {
        n++;
        cur = cur->next;
    }
    if (k > n)
    {
        return NULL;
    }
    cur = pListHead;
    int pos = n - k + 1;
    for (int i = 1; i < pos; i++)
    {
        cur = cur->next;
    }
    return cur;
}
//方法二:
struct ListNode* FindKthToTail(struct ListNode* pListHead, unsigned int k)
{
	struct ListNode* fast, * slow;
	fast = slow = pListHead;
	while (k--) //走k步
	{
		//k大于链表长度
		if (fast == NULL)
			return NULL;
		fast = fast->next;
	}
	while (fast)
	{
		slow = slow->next;
		fast = fast->next;
	}
	return slow;
}
//方法三:
struct ListNode* FindKthToTail(struct ListNode* pListHead, unsigned int k)
{
    struct ListNode* fast = pListHead;
    struct ListNode* slow = pListHead;
    while (--k)
    {
        if (fast == NULL)
        {
            return NULL;
        }
        fast = fast->next;
    }
    if (fast == NULL)
    {
        return NULL;
    }
    while (fast->next)
    {
        fast = fast->next;
        slow = slow->next;
    }
    return slow;
}

5.合并两个有序链表 

//合并两个有序链表
//不带哨兵位
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
	if (list1 == NULL)
	{
		return list2;
	}
	if (list2 == NULL)
	{
		return list1;
	}
	struct ListNode* begin1 = list1;
	struct ListNode* begin2 = list2;
	struct ListNode* newlist = NULL;
	struct ListNode* begin3 = newlist;
	while (begin1 != NULL && begin2 != NULL)
	{
		if (newlist == NULL)
		{
			if (begin1->val < begin2->val)
			{
				newlist = begin1;
				begin1 = begin1->next;
				begin3 = newlist;
			}
			else
			{
				newlist = begin2;
				begin2 = begin2->next;
				begin3 = newlist;
			}
		}
		else
		{
			if (begin1->val < begin2->val)
			{
				begin3->next = begin1;
				begin1 = begin1->next;
				begin3 = begin3->next;
			}
			else
			{
				begin3->next = begin2;
				begin2 = begin2->next;
				begin3 = begin3->next;
			}
		}
	}
	if (begin1 == NULL)
	{
		begin3->next = begin2;
	}
	if (begin2 == NULL)
	{
		begin3->next = begin1;
	}
	return newlist;
}
//带哨兵位
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
	struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
	guard->next = NULL;
	struct ListNode* tail = guard;
	struct ListNode* begin1 = list1;
	struct ListNode* begin2 = list2;
	while (begin1 && begin2)
	{
		if (begin1->val < begin2->val)
		{
			tail->next = begin1;
			begin1 = begin1->next;
			tail = tail->next;
		}
		else
		{
			tail->next = begin2;
			begin2 = begin2->next;
			tail = tail->next;
		}
	}
	if (begin1)
	{
		tail->next = begin1;
	}
	if (begin2)
	{
		tail->next = begin2;
	}
	struct ListNode* head = guard->next;
	free(guard);
	return head;
}

6.链表分割 

//链表分割
struct ListNode* partition(struct ListNode* pHead, int x)
{
	struct ListNode* lessGuard = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* lessTail = lessGuard;
	struct ListNode* greaterGuard = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* greaterTail = greaterTail;
	lessGuard->next = NULL;
	greaterGuard->next = NULL;
	struct ListNode* cur = pHead;
	while (cur)
	{
		if (cur->val < x)
		{
			lessTail->next = cur;
			cur = cur->next;
			lessTail = lessTail->next;
		}
		else
		{
			greaterTail->next = cur;
			cur = cur->next;
			greaterTail = greaterTail->next;
		}
	}
	lessTail->next = greaterGuard->next;
	greaterTail->next = NULL;
	pHead = lessGuard->next;
	free(greaterGuard);
	greaterGuard = NULL;
	free(lessGuard);
	lessGuard = NULL;
	return pHead;
}

7.链表的回文结构 

 

//链表的回文结构
//方法一:找中间结点翻转链表
struct ListNode* middleNode(struct ListNode* head)
{
	struct ListNode* slow = head;
	struct ListNode* fast = head;
	while (fast && fast->next)
	{
		slow = slow->next;
		fast = fast->next->next;
	}
	return slow;
}
struct ListNode* reverseList(struct ListNode* head)
{
	struct ListNode* prev = NULL;
	struct ListNode* cur = head;
	struct ListNode* next = NULL;
	while (cur)
	{
		next = cur->next;
		cur->next = prev;
		prev = cur;
		cur = next;
	}
	return prev;
}
bool chkPalindrome(struct ListNode* head)
{
	struct ListNode* mid = middleNode(head);
	struct ListNode* rmid = reverseList(mid);
	while (head && rmid)
	{
		if (head->val != rmid->val)
			return false;
		head = head->next;
		rmid = rmid->next;
	}
	return true;
}
//方法二:
struct ListNode* reverseList(struct ListNode* head)
{
	struct ListNode* prev = NULL;
	struct ListNode* cur = head;
	struct ListNode* next = NULL;
	while (cur)
	{
		next = cur->next;
		cur->next = prev;
		prev = cur;
		cur = next;
	}
	return prev;
}
bool isPalindrome(struct ListNode* head)
{
	struct ListNode* cur = head;
	struct ListNode* copyGuard = (struct ListNode*)malloc(sizeof(struct ListNode));
	copyGuard->next = NULL;
	struct  ListNode* copyTail = copyGuard;
	while (cur)
	{
		struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
		newnode->val = cur->val;
		copyTail->next = newnode;
		copyTail = copyTail->next;
	}
	copyTail->next = NULL;
	struct ListNode* rhead = reverseList(copyGuard->next);
	while (rhead || head)
	{
		if (rhead->val != head->val)
		{
			return false;
		}
		rhead = rhead->next;
		head = head->next;
	}
	free(copyGuard);
	copyGuard = NULL;
	return true;
}

8.相交链表 

//方法一:
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    struct ListNode* curA = headA;
	struct ListNode* curB = headB;
	while(curA != NULL)
    {
        while(curB != NULL)
        {
            if(curA == curB)
            {
                return curA;
            }
            curB = curB->next;
        }
        curB = headB;
        curA = curA->next;
    }
	return NULL;
}
//方法二:
struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB)
{
	if (headA == NULL || headB == NULL)
	{
		return NULL;
	}
	struct ListNode* curA = headA;
	struct ListNode* curB = headB;
	int lenA = 1;
	while(curA->next)
	{
		curA = curA->next;
		lenA++;
	}
	int lenB = 1;
	while (curB->next)
	{
		curB = curB->next;
		lenB++;
	}
	if (curA != curB)
	{
		return NULL;
	}
	struct ListNode* longList = headA;
	struct ListNode* shortList = headB;
	if (lenA < lenB)
	{
		longList = headB;
		shortList = headA;
	}
	int gap = abs(lenA - lenB);
	while (gap--)
	{
		longList = longList->next;
	}
	while (longList != shortList)
	{
		longList = longList->next;
		shortList = shortList->next;
	}
	return longList;
}

9.环形链表 

 

 

//环形链表
//快慢指针法:slow进环以后 fast开始追赶slow 
bool hasCycle(struct ListNode* head)
{
	struct ListNode* fast = head;
	struct ListNode* slow = head;
	while (fast && fast->next)
	{
		fast = fast->next->next;
		slow = slow->next;
		if (slow == fast)
		{
			return true;
		}
	}
	return false;
}

10.环形链表II

//环形链表II
//方法一:公式证明推导
struct ListNode* detectCycle(struct ListNode* head)
{
	struct ListNode* slow = head;
    struct ListNode* fast = head;
	while (fast && fast->next)
	{
		slow = slow->next;
		fast = fast->next->next;
		if (slow == fast)
		{
			struct ListNode* meet = slow;
			while (meet != head)
			{
				meet = meet->next;
				head = head->next;
			}
			return meet;
		}
	}
	return NULL;
}
//方法二:转换成相交问题
struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB)
{
	if (headA == NULL || headB == NULL)
	{
		return NULL;
	}
	struct ListNode* curA = headA, * curB = headB;
	int lenA = 1;
	//找尾结点
	while (curA->next)
	{
		curA = curA->next;
		lenA++;
	}
	int lenB = 1;
	while (curB->next)
	{
		curB = curB->next;
		lenB++;
	}
	if (curA != curB)
	{
		return NULL;
	}
	struct ListNode* longList = headA, * shortList = headB;
	if (lenA < lenB)
	{
		longList = headB;
		shortList = headA;
	}
	//长的链表先走差距步
	int gap = abs(lenA - lenB);
	while (gap--)
	{
		longList = longList->next;
	}
	//同时走找交点
	while (longList != shortList)
	{
		longList = longList->next;
		shortList = shortList->next;
	}
	return longList;
}
struct ListNode* detectCycle(struct ListNode* head)
{
	struct ListNode* slow = head;
	struct ListNode* fast = head;
	while (fast && fast->next)
	{
		slow = slow->next;
		fast = fast->next->next;
		if (slow == fast)
		{
			struct ListNode* meet = slow;
			struct ListNode* next = meet->next;
			meet->next = NULL;
			struct ListNode* entryNode = getIntersectionNode(head, next);
			meet->next = next;
			return entryNode;
		}
	}
	return NULL;
}

11.复制带随机指针的链表

//复制带随机指针的链表
struct Node
{
	int val;
	struct Node* next;
	struct Node* random;
};
struct Node* copyRandomList(struct Node* head)
{
	//1.插入copy结点
	struct Node* cur = head;
	struct Node* copy = NULL;
	struct Node* next = NULL;
	while (cur)
	{
		next = cur->next;
		copy = (struct Node*)malloc(sizeof(struct Node));
		copy->val = cur->val;
		cur->next = copy;
		copy->next = next;
		cur = next;
	}
	//2.更新random
	cur = head;
	while (cur)
	{
		copy = cur->next;
		if (cur->random == NULL)
		{
			copy->random = NULL;
		}
		else
		{
			copy->random = cur->random->next;
		}
		cur = cur->next->next;
	}
	//3.copy结点要解下来链接在一起 恢复原链表
	struct Node* copyHead = NULL;
	struct Node* copyTail = NULL;
	cur = head;
	while (cur)
	{
		copy = cur->next;
		next = copy->next;
		if (copyTail == NULL)
		{
			copyHead = copyTail = copy;
		}
		else
		{
			copyTail->next = copy;
			copyTail = copyTail->next;
		}
		//恢复原链表链接
		cur->next = next;
		cur = next;
	}
	return copyHead;
}

EnticE152
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode和oj-LeetCode-OJ:LeetCode-OJ
06-30
LeetCode-OJ 问题 # 标题 困难 标签 0233 数字一 中等的 数学 0229 多数元素 II 中等的 大批 0224 基本计算器 中等的 数学/堆栈 0216 组合和III 中等的 数组/回溯 0209 最小尺寸子阵列总和 中等的 数组/两个指针/二...
C语言单链表的总结
zdsey的博客
05-04 1580
文章目录初始节点结构：建链：插入：尾插法：头插法：打印链表：删除节点： 初始节点结构： struct ListNode { int val; struct ListNode *next; } 建链： struct ListNode* createlist() { struct ListNode* Hnode = (struct ListNode*)malloc(sizeof(struct ListNode)); Hnode -> next = NULL; return Hnode; }
【初阶数据结构与算法】第四篇：链表面试题详解
YQ20210216的博客
03-21 1511
⭐️本篇博客我要给大家分享一下算法中的链表例题。希望对大家有所帮助。 ⭐️ 博主码云gitee链接：码云主页 前言 ​ 🌏一、移除链表元素（传送门） 🍤给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5] 🔑思路： struct L...
反转链表（图文讲解）
m0_73935361的博客
01-02 1752
链表题目讲解
206 力扣 链表反转
m0_62953927的博客
03-18 451
迭代 struct ListNode* reverseList(struct ListNode* head) { struct ListNode* prev = NULL; struct ListNode* curr = head; while (curr) { struct ListNode* next = curr->next;//保存下一个结点位置 ,在下一轮循环中进行移动 curr->next = prev; ..
数据结构-链表篇
yixianfeng41的专栏
10-30 4920
链表作为数据结构主要组成部分之一，在面试中也是主要考点，花了几点时间把LeetCode上的链表的题做了一下，发现还是有规律可循的，特此总结下！
leetcode和oj-leetCode:尝试一些OJ
06-30
删除链表中的节点 45.0% 简单 349 % 两个数组的简单交集 00.00相同的树 44.8% Easy 171 Excel Sheet 列号 44.5% Easy 387 字符串中的第一个唯一字符 44.4% Easy 242 Valid Anagram 44.2% Easy 409 最长回文 44.1% ...
leetcode26-algo:算法与数据结构
07-07
算法与数据结构，练习代码 语言：java 8 开发工具：vscode，安装插件Java Extension Pack vscode有智能提示，可调试，有重构支持，满足代码练习要求，相比IDEA更轻量级，普通笔记本即可流畅运行。 每个练习代码中...
leetcode和oj-leetcode-master:leetcode大师
06-30
一些基本的数据结构初始化可能会被压缩，并在下面列出以供参考。 二叉树节点初始化如下： class TreeNode(object): def __init__(self, x): self.val = x self.left = None self.right = None 一个链表节点发起如下...
leetcode和oj-LeetCode:力码
06-30
oj LeetCode 好多题目没有数据范围，有点不适应。 Algorithms EASY: 　 　 　 [Running Sum of 1d Array ] 　 　 　 EASY 找规律 EASY 模拟 EASY 链表 EASY 贪心 EASY DP EASY ...
链表oj题详解
xbhinsterest11的博客
01-08 1293
1、上期反转链表的拓展解法（递归解法） 2、分割链表 3、回文链表的判断 4、环形链表的判断 5、环形链表入环结点的查找 6、链表的深拷贝 开始咯 都是链表题 /1、反转链表的递归解法 struct ListNode* reverseList(struct ListNode* head)//例 1 2 3 4 5 6 7 8 { if (head == NULL || head->next == NULL)//找尾结点 从尾结点开始 往前反转 return head.
链表相关题解
travel_dream的博客
04-09 1119
以下题目皆来自力扣和牛客，可以通过搜索题目名找到对应题目 前期最好配合画图进行解题，要进行特殊情况的考虑。 在进行链表题训练时，最好自己先画图，然后再进行代码的书写，卡壳了或者完全没有思路再看解析。只看完本篇文章不代表你能从容解决链表题。 1. 删除链表中等于给定值 val 的所有节点。//这里的头结点是链表实现的一种方式，后面会介绍到。 画图分析，因为返回头结点，所以可以不用考虑头指针的因素。在实现单链表时也可以这样创建节点，但是要额外创建变量接受指针(返回值)，每次创建节点都要创
【数据结构初阶】详解链表OJ题
喜欢就坚持吧
03-07 1438
目录。
C++ 自定义单向链表 ListNode
qq_43799400的博客
02-15 1266
直接上代码： #include <iostream> #include <assert.h> #include <vector> #include <algorithm> using namespace std; /* * 链表有两种： * 1、带头结点，头结点存放的是链表的长度，从第二个节点开始存放数据。 * 2、不带头结点，没有存放链表长度的节点，从头结点开始就存放数据。 * 我这里定义的链表是第二种。 */ struct ListNode {
简单解析链表
m0_62812354的博客
05-16 280
目录 链表的基本结构 链表的分类 链表的实现 单向不带头不循环链表实现 双向带头循环链表的实现 顺序表和链表的区别 链表的基本结构 在学习C语言时，我们学到了一个简单的用来存放数据的结构——数组。但在学习数组的时候，我们肯定知道：数组的每一个元素的存储空间都是连续的，并且他的长度是固定的，在数组元素满了的话，就要删除，或者是用realloc函数来给数组扩容，最让人头疼的就是如果要在数组中间插入或删减一个元素的话，需要同时改动后面的其他元素。 而今天我们要讲的链表则是一种物理存储结构..
链表试题之链表分割
qq_56663697的博客
09-01 209
题目简介 现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。 链表分割 思路分析 代码实现 struct ListNode* partition(pHead,x) { // write code here struct ListNode* greatertail, *greaterhead, *lesstail, *lesshead; greaterhead = greatertai
数据结构OJ习题
weixin_45882127的博客
01-13 1548
数据结构OJ习题 问题 A: 顺序表上的基本操作实现 题目描述 在顺序存储结构实现基本操作：初始化、创建、插入、删除、查找、遍历、逆置、合并运算。 输入 请输入线性表La的长度:n a1 a2 a3 …an（数值有序，为降序） 请输入要插入到线性表La中的数字x和插入的位置i:x i 请输入要删除数字的位置:i 请输入要查找的数字:x 请输入线性表长度:m b1 b2…bm(数值有序，为升序) 输出 插入一个数字后的线性表a1 a2…an+1 删除一个数字后的线性表a1 a2…an 查找一个输入的数字后如果
【数据结构】详解11道链表OJ题（万字详解）
丨归凡的博客
08-11 696
万字详解11道链表OJ题，图文并茂，一题多解。
线性表的链式存储结构——链表学习记录
nous_x的博客
04-13 311
链表总结 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct ListNode{ int val; struct ListNode* next; }ListNode; struct ListNode* createListtail(struct ListNode* L){/*尾插创建含头结点的链表，输入-1终止。 */ int n; scanf("%d",&n);
sdut数据结构链表
最新发布
09-07
SDUT数据结构链表是指山东理工大学数据结构课程中使用的链表。链表通常以结构体的形式进行表示和操作。在C和C++语言中，我们可以使用结构体来定义链表的节点，如引用所示。每个节点包含一个数据字段date和一个指向下...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值