【数据结构与算法】---OJ手撕链表题

旧梦拾遗186

已于 2022-08-07 10:58:45 修改

阅读量191

点赞数 13

分类专栏：数据结构成长日记

于 2022-08-07 08:25:44 首次发布

本文链接：https://blog.csdn.net/weixin_67900732/article/details/126205650

版权

链表数据结构 c语言算法 c++

数据结构成长日记专栏收录该内容

17 篇文章 1 订阅

订阅专栏

作者：旧梦拾遗186

专栏：数据结构成长日记

链表的中间结点

链表的中间结点https://leetcode.cn/problems/middle-of-the-linked-list/

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

示例 1：

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.
示例 2：

输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

提示：

给定链表的结点数介于 1 和 100 之间。

题解

思路：可以遍历一遍求出长度在除以2。不过我们采用另一种做法只遍历链表一遍即可，采用快慢指针即可。慢指针一次走一步，快指针一次走两步，我们要区分是奇数个结点还是偶数个结点。

对于奇数个：fast到尾，而slow刚好到中间结点

对于偶数个：fast走到空，而slow刚好走到中间结点。
struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* fast=head;
    struct ListNode* slow=head;
    while(fast!=NULL&&fast->next!=NULL)
    {
        
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;

}

链表中倒数第k个结点

链表中倒数第k个结点https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId=13&&tqId=11167&rp=2&ru=/activity/oj&qru=/ta/coding-interviews/question-ranking

描述

输入一个链表，输出该链表中倒数第k个结点。

示例1

输入：
1,{1,2,3,4,5}
返回值：
{5}

题解

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* fast=pListHead;
    struct ListNode* slow=pListHead;
    int i=0;
    for(i=0;i<k;i++)
    {
         
        if(fast==NULL)
            return NULL;
       
       fast=fast->next;
    }
    while(fast)
    {
        fast=fast->next;
        slow=slow->next;
    }
    return slow;
    
}

class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        struct ListNode* slow = pListHead;
        struct ListNode* fast = slow;
        while(k--)
        {
            if(fast)
                fast = fast->next;
            else
                return NULL;
        }
         
        while(fast)
        {
            slow = slow->next;
            fast = fast->next;
        }
         
        return slow;
    }
};

链表的分割

链表分割https://www.nowcoder.com/practice/0e27e0b064de4eacac178676ef9c9d70?tpId=8&&tqId=11004&rp=2&ru=/activity/oj&qru=/ta/cracking-the-coding-interview/question-ranking

描述

现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

题解

思路：我们给出两个带头结点的新链表，值小于X的放在第一条链表，值大于X的放在第二条链表，最后两个新链表连接起来即可。同时，我们需要注意到如果链表为空的时候，我们可以画个图：

public:
    ListNode* partition(ListNode* pHead, int x) {
        // write code here
        ListNode*lessguard = (ListNode*)malloc(sizeof(ListNode));
        lessguard->next = NULL;
        ListNode*lesstail = lessguard;
        ListNode*greaterguard = (ListNode*)malloc(sizeof(ListNode));
        greaterguard->next =NULL;
        ListNode*greatertail = greaterguard;
        ListNode*cur = pHead;
        while(cur)
        {
            if(cur->val<x)
            {
                lesstail->next = cur;
                lesstail = lesstail->next;
            }
            else
            {
                greatertail->next = cur;
                greatertail = greatertail->next;
            }
            cur = cur->next;
        }
        lesstail->next = greaterguard->next;
        greatertail->next = NULL;
        pHead = lessguard->next;
        free(lessguard);
        free(greaterguard);
        return pHead;
    }
};