【剑指offer专项突破版】链表篇——“C“

已于 2023-06-11 17:37:46 修改
阅读量905 收藏 1
点赞数 1
分类专栏： 剑指offer专项突破版 文章标签： 链表 c语言 面试 算法 剑指offer专项突击版
于 2023-06-11 17:37:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shun_Hua/article/details/131145751
版权

文章目录

前言

剑指offer专项突破版（力扣官网）——> 点击进入
本文所属专栏——>点击进入

一.删除链表的倒数第 n 个结点

题目分析

![在这里插入图片描述](https://img-blog.csdnimg.cn/8db53ca053dc44afbce2bb45824524a5.

  • 总结

数据格式——链表——结点数大于等于1，且n是符合要求的！
要求——删除链表的n个结点
返回——返回链表的头结点

思路分析

 倒数第n个结点——>到最后一个结点的步长为n-1。到最后一个结点很容易，所以我们只需一个步长n-1距离即可，那么思路就很明显了，定义一个end指针走n-1步，再定义一个cur指针，从头节点开始跟end指针一块走，当end指针到最后一个结点(非空)时，这时cur与最后一个结点的距离为n-1，此时cur指向的不就是倒数第n个结点吗？

细节分析

 1. 为了删除这个结点，我们还需要保存前一个节点。
 2.当删除倒数第n个结点时，我们只能删除头结点，并将之指向下一个节点。

步骤

1.定义end指针，走n-1步停下来。
2.定义cur指针，跟end再一块走，直到end指向最后一个非空节点。
3.处理最后情况: 如果cur等于头指针，则进行头删操作;如果不等于则，cur前一个节点的下一个节点指向cur的下一个节点。然后释放cur节点。

代码

typedef struct ListNode Node;
struct ListNode* removeNthFromEnd(struct ListNode* head, int n)
{
    Node* end = head;
    while(--n)
    {
        end = end->next;
    }
    Node* cur = head;
    Node* prev = head;
    while(end->next)
    {
        end = end->next;

        prev = cur;
        cur = cur->next;
    }
    //分析情况，看是否需要修改头结点
    if(cur==head)
    {
        head = cur->next;
    }
    else
    {
        prev->next = cur->next;
    }
    free(cur);
    return head;
}

二.链表中环的入口节点

题目分析

在这里插入图片描述

  • 总结

数据格式——可能是环形链表也可能不是环形链表。
要求——找到入环节点。
返回值——入环节点。

思路分析

这里对下面的图补充一个词——相遇。
在这里插入图片描述

写法①代码

struct ListNode *detectCycle(struct ListNode *head) 
{
    struct ListNode* fast = head,* slow = head;
    while(fast&&fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
        if(fast == slow)
        {
            struct ListNode* start = fast;
            struct ListNode* begin = head;
            while(start!=begin)
            {
                begin = begin->next;
                start = start->next;
            }
            return start;
        }
    }
    return NULL;   
}

写法②代码:

typedef struct ListNode Node;
struct ListNode *detectCycle(struct ListNode *head) 
{
    if(head == NULL)
    {
        return NULL;
    }
    Node* fast = head->next;
    Node* slow = head;
    while(fast&&fast->next&&fast!=slow)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    if(fast==NULL||fast->next==NULL)
    {
        return NULL;
    }
    Node* begin = fast->next;
    Node* start = head;
    while(begin!=start)
    {
        begin = begin->next;
        start = start->next;
    }
    return begin;
}

三.两个链表的第一个重合节点

题目分析

在这里插入图片描述

  • 总结

1.数据——所给两个链表，可能不相交，但不存在环。
2.要求——找到第一个相交的结点。
3.返回值——第一个相交的结点。

思路分析

  • 双指针——对齐一块走
    在这里插入图片描述

代码

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    int len_A = 0,len_B = 0;
    struct ListNode* A = headA,*B = headB;
    while(A||B) 
    {
        if(A)
        {
            A = A->next;
            len_A++;
        }
        if(B)
        {
            B = B->next;
            len_B++;
        }
    }
    A = headA;
    B = headB;
    int k =abs(len_B-len_A);
    //长度对齐
    while(k--)
    {
        if(len_A>len_B)
        {
            A= A->next; 
        }
        else
        {
            B = B->next;
        }
    }
    while(A!=B)
    {
        A = A->next;
        B = B->next;
    }
    //如果没有相交节点，则最后结果为空时，相等也会结束循环
    return A;
}

四.反转链表

题目分析

在这里插入图片描述

  • 总结

数据——单链表
要求——反转整个链表
返回——反转后链表的头结点

思路分析

方法一:

法①代码

typedef struct ListNode Node;
struct ListNode* reverseList(struct ListNode* head)
{
    //在原链表的基础上进行操作
    //首先我们知道链表需要反转的条件是有两个或两个以上的结点
    if(head&&head->next)
    {
        //我们需要换方向的话需要三个指针
        //当前的需要改变方向的两个指针
        Node* cur = head->next;
        Node* prev = head;
        Node* next = cur->next;
        while(cur)
        {
            if(prev==head)
            {
                prev->next = NULL;
            }
            cur->next = prev;
            prev = cur;
            cur = next;
            if(next)
            {
                next = next->next;
            }
        }
        return prev;
    }
    else
    {
        //这里只有一个结点直接返回头结点即可
        return head;
    }
}

方法二:
在这里插入图片描述

法②代码

typedef struct ListNode Node;
struct ListNode* reverseList(struct ListNode* head)
{
    Node* cur = head;
    Node* prev = head;
    Node* new_head = NULL;
    while(cur)
    {
        prev = cur;
        cur = cur->next;
        prev->next = new_head;
        new_head =prev;
    }
    return new_head;
}

方法三:
 反转链表问题可以不断拆解为,反转前一个结点和剩余结点，以此类推最终反转整个链表，不过需要注意的是第一次反转的一个空结点和头结点，最后一次反转遇到空节点，直接返回最后一个非空节点即可。

法③代码

typedef struct ListNode Node;
Node* reverse(Node* cur,Node* next,Node* new_head)
{
    if(next&&next->next)
    {
        new_head = reverse(next,next->next,new_head);
    }
    if(next&&next->next==NULL)
    {
        new_head = next;
    }
    if(next)
    {
        next->next = cur;
    }
    return new_head;
}
struct ListNode* reverseList(struct ListNode* head)
{
    return reverse(NULL,head,NULL);
}

五.链表中的两数相加

题目分析

在这里插入图片描述

  • 总结

数据格式——非空链表。
要求——将链表的值进行相加。
返回——一个新链表。

思路分析

在这里插入图片描述

代码

typedef struct ListNode Node;
Node* reverselist(Node* head)
{
    Node* prev = head;
    Node* cur = head;
    Node* new_head = NULL;
    while(cur)
    {
        prev =  cur;
        cur = cur->next;
        prev->next = new_head;
        new_head = prev;
    }
    return new_head;
}

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2)
{
    Node* head1 = reverselist(l1);
    Node* head2 = reverselist(l2);
    Node* sum_head = NULL;
    int carry = 0;
    while(head1||head2)
    {
        int sum = (head1 != NULL ? head1->val : 0)\
         +(head2 != NULL ? head2->val : 0) + carry;
        int cur = sum%10;
        carry = sum/10;
        Node* NewNode = (Node*)malloc(sizeof(Node));
        NewNode->val = cur;
        NewNode->next = sum_head;
        sum_head = NewNode;
        head1 = head1 != NULL ? head1->next : NULL;
        head2 = head2 != NULL ? head2->next : NULL;
    }
    if(carry)
    {
        Node* NewNode = (Node*)malloc(sizeof(Node));
        NewNode->val = carry;
        NewNode->next = sum_head;
        sum_head = NewNode;
    }
    return sum_head;
}

六.重排链表

题目分析

在这里插入图片描述

思路分析

找到中间结点，反转之后的链表，再进行重新进行排序。
在这里插入图片描述

代码

typedef struct ListNode Node;
struct ListNode* reverseList(struct ListNode* head)
{
    Node* cur = head;
    Node* prev = head;
    Node* new_head = NULL;
    while(cur)
    {
        prev = cur;
        cur = cur->next;
        prev->next = new_head;
        new_head =prev;
    }
    return new_head;
}
void reorderList(struct ListNode* head)
{
    //找到中间结点
    Node* fast = head;
    Node* slow = head;
    while(fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    //此时slow即为中间结点
    //反转slow后面的链表

    Node* head1 = slow->next;
    slow->next = NULL;
    head1 = reverseList(head1);

    //head1链表插在head的前半个链表中
    Node *prev = head;
    Node* cur = head;
    Node* cur1 = head1;
    Node* prev1 = head1;
    while(cur&&cur1)
    {
        prev = cur;
        cur = cur->next;

        prev1 = cur1;
        cur1 = cur1->next;

        prev->next = prev1;
        prev1->next = cur;
    }
    return head;    
}

七.回文链表

题目分析

在这里插入图片描述

思路分析

找到中间结点，然后让中间结点及其以后的结点进行逆转，再进行判断即可。
在这里插入图片描述

代码

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

bool isPalindrome(struct ListNode* head)
{
    //找到中心结点
    struct ListNode* slow = head,*fast = head,*prev = head;
    while(fast&&fast->next)
    {
        prev = slow;
        fast = fast->next->next;
        slow = slow->next;
    }
    struct ListNode* new_head = slow;
    //进行后半部分链表的反转工作
    new_head = reverseList(new_head);
    struct ListNode* begin = head;
    //判断是否是回文
    while(new_head&&begin)
    {
        if(new_head->val!=begin->val)
        {
            return false;
        }
        new_head = new_head->next;
        begin = begin->next;
    }
    return true;
}

八. 展平多级双向链表

题目分析

在这里插入图片描述

  • 总结

数据——多级双向链表
要求——将此种链表展平
返回——头结点

思路分析

找到就进行展平。
在这里插入图片描述

代码

 Node* flatten(Node* head) 
    {
        Node* head1 = head;
        while(head1)
        {
            Node* child = head1->child;
            Node* child_end = NULL;
            Node* prev = child;
            if(child)
            {
                child_end = child;
                while(child_end)
                {
                    prev = child_end;
                    child_end = child_end->next;
                }
                if(head1->next)
                {
                    head1->next->prev = prev;
                    prev->next = head1->next;

                    child->prev = head1;
                    head1->next = child;
                }
                else
                {
                    child->prev = head1;
                    head1->next = child;
                }
                //展平操作
                head1->child = NULL;
            }
            head1 = head1->next;
        }
        return head;
    }

九.排序的循环链表

题目分析

在这里插入图片描述

思路分析

1.当所给链表为空时，这时我们需要自己把插入结点，构造成环，即自己指向自己，并返回构造的结点。
2.当所给链表不为空时，我们需要找到最大最小结点，并且判断插入结点的值是否大于最大的结点值。
3. 继续处理找到第一个大于等于插入值的结点，同时保存此节点的前一个节点。将插入结点插入在两节点之间。
4. 返回头结点。

代码

typedef struct Node Node;
struct Node* insert(struct Node* head, int insertVal) 
{
    Node* inser = (Node*)malloc(sizeof(Node));
    inser->val = insertVal;
    //处理为空的情况
    if(head == NULL)
    {
        inser->next = inser;
        return inser;
    }
    else
    {
        //找到最大和最小节点
        Node* max = head;
        Node* min = head->next;
        while(min->val >= max->val && min!=head)
        {
            min = min->next;
            max = max->next;
        }
        //处理插入结点大于等于最大节点的情况
        if(inser->val >= max->val)
        {
            inser->next = min;
            max->next = inser;
        }
        else
        {
            //找到大于等于inser的第一个节点
            Node* prev = max;
            Node* cur = min;
            while(inser->val > cur->val)
            {
                prev = cur;
                cur = cur->next;
            }
            prev->next = inser;
            inser->next = cur;
        }
    }
    return head;
}
舜华丶
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指Offer（专项突破版）数据结构与算法名企面试题精讲1
08-03
《剑指Offer（专项突破版）数据结构与算法名企面试题精讲1》是一本专为程序员面试准备的数据结构与算法指南。作者何海涛结合自身多年的面试官经验，深入探讨了程序员在面试中必须掌握的核心知识。本书旨在帮助读者...
《剑指Offer》刷题笔记——面试题06. 从尾到头打印链表
01-21
1、剑指解析： 2、代码实现： I、辅助栈 from typing import List ###### 代码主体 ###### class Solution: def reversePrint(self, head: ListNode) -> List[int]: stack = [] if head is None: return [] ...
【剑指offer专项突破版】哈希表篇——“C“
Shun_Hua的博客
06-15 1169
本篇主要解决了6道面试题，包括插入、删除和随机访问都是 O(1) 的容器，最近最少使用缓存，有效的变位词，变位词组，外星语言是否排序，最小时间差。
【剑指offer专项突破版】队列篇——“C“
Shun_Hua的博客
06-21 766
本篇共六道题，滑动窗口的平均值，最近请求次数，往完全二叉树添加节点，二叉树每层的最大值，二叉树最底层最左边的值，二叉树的右侧视图。
剑指Offer专项突破版（26）—— 重排链表
qq_39383767的博客
11-17 199
重排链表
【leetcode】剑指 Offer（专项突击版）汇总
Friedrichor的博客
08-05 1342
更新中…… leetcode 剑指 Offer（专项突击版）题目+个人题解 汇总
【leetcode】剑指offer专项突击版详解（C++）
froot的博客
12-02 2611
题目所在链接： leetcode剑指offer专项突击版 1. 整数 剑指 Offer II 002. 二进制加法 class Solution { public: string addBinary(string a, string b) { int carry = 0; string res; int i = a.size() - 1; int j = b.size() - 1; while(i >= 0 ||
剑指offer（第2版）——链表相关题目
Everest_vv的博客
02-21 105
本文是力扣中剑指offer（第2版）中与链表有关的题目，整理发布出来，一是整理自己的思路加深印象，二是方便大家专项刷题。
剑指Offer专项突破版（55）—— 二叉搜索树迭代器
qq_39383767的博客
11-21 83
原地遍历
剑指 Offer II 022. 链表中环的入口节点(力扣剑指Offer专项突击版——链表2)
weixin_47460769的博客
03-26 175
题目 给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表节点 解释：链表中有一个环，其尾部连接
【Leetcode训练】剑指 Offer（专项突击）——双指针全刷
胡毛毛的博客
01-16 1147
目录[剑指 Offer II 006. 排序数组中两个数字之和](https://leetcode-cn.com/problems/kLl5u1/)——简单题目描述：题解方法一：数组已经排序了，直接首尾双指针；[剑指 Offer II 007. 数组中和为 0 的三个数](https://leetcode-cn.com/problems/1fGaJU/)——中等题目描述题解：方法一：暴力破解（超时）方法二：双指针[剑指 Offer II 014. 字符串中的变位词](https://leetcode-cn.
剑指offer刷题日记-链表
01-20
链表03-从尾到头打印链表（python） #采用insert方法 class Solution: def printlist(self,listNode): if not listNode: return [] result=[] while listNode: result.insert(0,listNode.val) ...
《剑指Offer》刷题笔记——面试题24. 反转链表
01-20
难度：简单 一、题目描述： 二、解题分析： 1、leetcode解析 2、测试用例 3、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): ... def reverseList(self, head: ...
剑指offer之链表（python版）
12-22
链表是一种基础的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在Python中，我们可以自定义一个类来表示链表节点...掌握链表操作对于理解和解决《剑指Offer》中的其他编程问题也是必要的。
笔记——C语言
最新发布
2301_80191662的博客
07-24 291
int 就是等价于signed int, short也是等价于signed short， long也是等价于signed long， long long也是等价于signed long long。char ---- char 到底是有符号还是无符号呢？编程是为了解决生活中的问题，计算机语言来写代码——得有能力描述生活中的问题，那么生活中有那么多数据，因此C语言中有许多的数据类型。运算符的返回值，C 语⾔只规定是⽆符号整数，并没有规定具体的类型，⽽是留给。这个转义字符，光标回退一个字符，到底会不会删除字符？
【C语言】函数
2402_85428625的博客
07-23 1206
1. 函数的概念 2. 库函数 2.1 标准库和头⽂件 2.2 库函数的使⽤⽅法 2.2.1 功能 2.2.2 头⽂件包含 2.2.3 实践 2.2.4 库函数⽂档的⼀般格式 3. ⾃定义函数 3.1 函数的语法形式 3.2 函数的举例 4. 形参和实参 4.1 实参 4.2 形参 4.3 实参和形参的关系 5. return语句 6. 数组做函数参数 7. 嵌套调⽤和链式访问 7.1嵌套调用 7.2 链式访问 8. 函数的声明和定义 8.1 单个⽂件 8.2 多个⽂件 8.3static 和 extern
【C语言】数组名的不同情况
学习笔记，与你共享的宝藏，记录学习过程的点滴，分享学习的心得体会
07-24 814
在C语言中，数组名在绝大多数情况下表现为指向数组第一个元素的指针。具体而言，当数组名出现在表达式中（除了作为函数参数时的特殊情况），它会被视为指向数组首元素的常量指针。这意味着你可以使用下标运算符来访问数组中的元素，也可以进行指针算术来遍历数组。然而，当数组名作为函数参数被传递时，它会退化为一个普通指针，失去了与原始数组大小和边界的相关信息。在函数内部，这个指针仅仅指向了传入数组的第一个元素，而不携带任何有关整个数组的信息，除非另外传递数组的大小。
30.【C语言】函数系列下
2401_85828611的博客
07-23 350
打印123，返回3作为参数给printf，打印3返回1作为参数给printf，打印1。*定义：将一个函数的返回值作为另外一个函数的参数，像链条一样将函数串起来就是函数。strlen函数的返回值作为printf的参数。查阅printf的返回值：字符的个数。3个printf，由里向外执行。*定义：函数之间的互相调用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值