Leetcode刷题——链表

于 2023-01-06 22:25:25 发布
阅读量127 收藏
点赞数
分类专栏： 今天刷题了吗 文章标签： 链表 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44205451/article/details/128585535
版权

1.相交链表
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *longList, *shortList;
        int interval=0;
        ListNode *p = new ListNode(0);
        ListNode *q = new ListNode(0);
        p->next = headA;
        q->next = headB;
        // 计算链表的长度
        int lenA = ListLenght(p);
        int lenB = ListLenght(q);
        if(lenA>lenB){
            longList = p;
            shortList = q;
            interval = lenA-lenB;
        }
        else{
            longList = q;
            shortList = p;
            interval = lenB-lenA;

        }
       //将长的那一方进行移动
        while(interval--){
            longList = longList->next;
        }
        //找到两者相交的地方
        while(longList->next){
            // cout<<longList->next->val;
            if(longList->next==shortList->next){
                return longList->next;
            }
            longList = longList->next;
            shortList = shortList->next;
        }
        return NULL;     
    }
    int ListLenght(ListNode *head){
        ListNode *p = head;
        int count = 0;
        while(p->next){
            count++;
            p = p->next;
        }
        return count;
    }
};

反转链表
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
       ListNode *p = new ListNode(0); //创建头节点
       p->next = head;
       ListNode *q = p->next;  
       p->next=nullptr;
       while(q){  //利用头插法
           ListNode *temp = q->next;
           q->next = p->next;
           p->next = q;
           q=temp;
       }
       return p->next;
    }
};

3.归并两个有序的链表
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode *ans = new ListNode(0); //创建结果链表的头节点
        ListNode *res = ans; //尾部结点
        ListNode *p = list1, *q = list2;
        while(p && q){
            if(p->val < q->val){
                res->next = p;
                p = p->next;
            }
            else{
                res->next = q;
                q = q->next;
            }
            res = res->next;
        }
        ListNode *rest; //判断是否有盈余
        rest = (p==nullptr)?q:p;   
        while(rest){
            res->next = rest;
            rest = rest->next;
            res = res->next;
        }
        res->next = nullptr;  //最后一个结点的尾部置为null
        return ans->next;
    }
};

4.从有序链表中删除重复节点
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head || !head->next){
            return head;
        }
        ListNode *head1 = new ListNode();
        head1->next = head;
        ListNode *p = head1->next;
        ListNode *q = p->next;
        while(q){
            if(q->val == p->val){
                q=q->next;
                p->next = q;
            }
           else{
               p = p->next;
               q = q->next;
           }
        }
        p->next = nullptr;
        return head1->next;
    }
};

5.删除链表的倒数第 n 个节点
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *pre = new ListNode(0);
        pre->next = head;
        ListNode *p = pre;
        ListNode *q = p->next;
        int len = listLen(pre);
        int index = len-n;
        int k = 0;
        while(q && k!=index){
            k++;
            p->next = q;
            p = p->next;
            q = q->next; 
        }
        p->next = q->next;
        return pre->next;
    }
    //计算带有头节点的链表的长度
    int listLen(ListNode *head){
        ListNode *p = head->next;
        int k = 0;
        while(p){
            k++;
            p = p->next;
        }
        return k;
    }
};

6.两两交换链表中的节点
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(!head || !head->next){
            return head;
        }
        ListNode *L = new ListNode(0);
        L->next = head;
        ListNode *pre = L;
        ListNode *p = head;
        ListNode *q = p->next;
        while(p && q){
            ListNode *p1 = q->next;
            pre->next = q;
            pre = pre->next;
            pre->next = p;
            pre = pre->next;
            p = p1;
            if(p && p->next){
                q = p->next;
            }
            else{
                break;
            }
        }
        if(p){
            pre->next = p;
            pre = pre->next;
        }
        pre->next = nullptr;
        return L->next;

    }
};

7.链表求和
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *p1 = new ListNode(0);
        p1->next = l1;
        ListNode *p2 = new ListNode(0);
        p2->next = l2;
        p1 = reverseList(p1);
        p2 = reverseList(p2);
        int cur = 0;
         ListNode *res = new ListNode(0);
        ListNode *p = p1->next;
        ListNode *q = p2->next;
        ListNode *pp;
        while(p && q){
            int temp = (p->val +q->val+cur);
            cur = temp/10;
            p->val = temp%10;
            pp = p->next;
            p->next = res->next;
            res->next = p;
            p = pp;
            q = q->next;
        }
        if(q){
            p=q;
        }
        while(p){
            int temp = p->val+cur;
            p->val = temp % 10;
            cur = temp /10;
            pp = p->next;
            p->next = res->next;
            res->next = p;
            p = pp;
        }
       
        if(cur>0){
            ListNode *last = new ListNode(cur);
            last->next = res->next;
            res->next = last;
        }
        return res->next;
    }
    //将带有头结点的链表逆序
    ListNode* reverseList(ListNode* head){
        ListNode *pre = head;
        ListNode *p = pre->next;
        pre->next = nullptr;
        while(p){
            ListNode *q = p->next;
            p->next = pre->next;
            pre->next = p;
            p = q;
        }
        return pre;
    }
};

8.回文链表
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(!head || !head->next) return true;
        stack<int> s;
        ListNode *p = head;
        //计算链表的长度
        int len = 0;
        while(p){
            len++;
            p = p->next;
        }
        int mid = len/2;
        int count = 0;
        p = head;
        while(p){
            count++;
            if(count<=mid){
                s.push(p->val);
                if(count==mid && len%2==1){
                   p = p->next;
                   count++;
                }
            }
            else{
                if(s.top()!=p->val) return false;
                else{
                    s.pop();
                }
            }
            p = p->next; 
        }
        if(s.empty()) return true;
        else 
            return false;
        
    }
};

9.分隔链表
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    vector<ListNode*> splitListToParts(ListNode* head, int k) {
        //计算链表长度
        ListNode *p = head;
        int len = 0;
        while(p){
            len++;
            p = p->next;
        }
        int ave = len/k;
        int rest = len%k;
        vector<ListNode *> res(k);
        p = head;
        for(int i=0;i<k;i++){
            res[i] = p;
            ListNode *tail = res[i];
            ListNode *q;
            for(int j=1;j<=ave;j++){
                q = p->next;
                tail->next = p;
                tail = tail->next;
                p = q;
                
            }
            if(rest){
                q = p->next;
                tail->next = p;
                tail = tail->next;
                rest--;
                p = q;
                
            }
            if(tail)
                tail->next = nullptr;
        }
        return res;
    }
};

10.链表元素按奇偶聚集
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(!head || !head->next) return head;
        ListNode *Dtail = head;
        ListNode *Otail = head->next;
        ListNode *p = Dtail;
        ListNode *q = head->next;
        ListNode *t = q->next; 
        while(t && t->next){
           ListNode *temp = t->next->next;
           p->next = t;
           p=p->next;
           q->next = t->next;
           q = q->next;
           t = temp;
        }
        if(t){
            p->next = t;
            p = p->next;
        }
        p->next = Otail;
        q->next = nullptr;
        return Dtail;
        
    }
};
韩豆豆小姐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（C++）LeetCode刷题题解答案
02-20
（C++）LeetCode刷题题解答案
leetcode刷题——链表
xxp的博客
03-12 253
leetcode刷题——链表
LeetCode刷题——链表2
fudaodao的博客
09-11 107
LeetCode刷题——链表2删除链表的倒数第 N 个结点链表相交环形链表 II 删除链表的倒数第 N 个结点 题目链接. 题意：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。 思路： 遍历链表，得到链表长度，计算倒数第n个节点是正序的第几个节点，然后遍历删除该节点（暴力）。 class Solution { public: ListNode* removeNthFromEnd(ListNode* head, int n) { ListNode * dum
leetcode刷题——链表篇
qq_43651945的博客
05-11 212
例题1移除链表的指定元素 203. 移除链表元素 - 力扣（LeetCode） (leetcode-cn.com) 头部的处理和后续的处理有不同，所以有两种处理方式； 方式一先处理头部 while(head!=null && head.val==val){ head=head.next; } if(head==null) return head; //头结点为空直接结束 方式二加入一个新的头结点，统一处理 if (head == null) { re
LeetCode刷题——链表（python语言）
qq_26274961的博客
02-17 769
LeetCode刷题——链表（python语言） 一、链表 1.1 逻辑结构与存储结构 1.1.1 逻辑结构 逻辑结构：数据元素之间的逻辑关系 集合、线性结构（一对一）、树形结构（一对多）、图结构（多对多） 1.1.2 存储结构 存储结构包括顺序存储、链式存储、索引存储、散列存储 顺序存储（顺序表）：逻辑上相邻的元素物理位置也相邻 链式存储（单链表）：逻辑上相邻的元素物理位置不一定相邻 1.2 单链表 1.2.1 单链表的定义 带头节点的单链表（写代码方便） 不带头结点的单链表（写代码麻烦） class L
LeetCode刷题——旋转图片
12-23
旋转图片题目的思路探讨与源码 旋转图片的题目如下图，核心是把一个矩阵进行顺时针90度的旋转，并且只能在当前矩阵上改动，不能新建矩阵，所以只需要把该矩阵旋转问题看作是矩阵内的数字移动的步骤即可。...
LeetCode刷题模板.pdf
04-05
1.4. LeetCode中二分查找题目 29 2. 双指针 30 2.1. 快慢指针 31 2.1.1. 什么是快慢指针 31 2.1.2. 快慢指针模板 31 2.1.3. 快慢指针相关题目 32 2.1.3.1. LC-141:链表是否有环 32 2.1.3.2. LC-142:环形链表入口 34 ...
LeetCode刷题笔记.rar
07-05
LeetCode刷题笔记
二叉树的层序遍历习题集锦
韩豆豆小姐的博客
10-22 1731
想说点东西给我自己 啊，鬼知道我这一周到底干了啥；干啥啥不行，吃饭第一名，冬天快要来了，有羽绒服不需要脂肪来御寒，请有点自知之明，微笑脸。要把前几天没做的给补回来 这次就来个二叉树的二层次遍历叭，从二叉树的层次遍历可以延伸出好多题目 层次遍历集锦 1.102. 二叉树的层序遍历 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,20,null,null,15,7] /** * Definition for a binary tree
Leetcode508. 出现次数最多的子树元素和
韩豆豆小姐的博客
10-31 974
链接：https://leetcode-cn.com/problems/most-frequent-subtree-sum 给你一个二叉树的根结点，请你找出出现次数最多的子树元素和。一个结点的「子树元素和」定义为以该结点为根的二叉树上所有结点的元素之和（包括结点本身）。 你需要返回出现次数最多的子树元素和。如果有多个元素出现的次数相同，返回所有出现次数最多的子树元素和（不限顺序）。 /** * Definition for a binary tree node. * struct TreeNode {
LeetCode 111. 二叉树的最小深度
韩豆豆小姐的博客
10-08 151
给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明: 叶子节点是指没有子节点的节点。 分析：乍一看，我以为是和求二叉树的高度那种思想一样，返回的结果是二叉树左右子树最小高度+1，可是 忽略了左右子树可能有一方为空的情况，就是二叉树呈现单支的情况 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; *
Leetcode刷题——数组
韩豆豆小姐的博客
12-21 144
CS人笔刷系列——数组
Leetcode1038. 把二叉搜索树转换为累加树
韩豆豆小姐的博客
11-05 140
链接：https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/ 给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。 提醒一下，二叉搜索树满足下列约束条件： 节点的左子树仅包含键 小于 节点键的节点。 节点的右子树仅包含键 大于 节点键的节点。 左右子树也必须是二叉搜索树。 思路：二叉树
Leetcode701. 二叉搜索树中的插入操作
韩豆豆小姐的博客
11-02 134
链接：https://leetcode-cn.com/problems/insert-into-a-binary-search-tree 给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。 思路：利用二叉搜索树的性质；递归 /** * Definition for a binary t
Leetcode654. 最大二叉树
韩豆豆小姐的博客
11-01 130
链接：https://leetcode-cn.com/problems/maximum-binary-tree 给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下： 二叉树的根是数组中的最大元素。 左子树是通过数组中最大值左边部分构造出的最大二叉树。 右子树是通过数组中最大值右边部分构造出的最大二叉树。 通过给定的数组构建最大二叉树，并且输出这个树的根节点。 /** * Definition for a binary tree node. * struct TreeNode { *
leetcode 606. 根据二叉树创建字符串
韩豆豆小姐的博客
10-18 126
题目链接https://leetcode-cn.com/problems/construct-string-from-binary-tree 你需要采用前序遍历的方式，将一个二叉树转换成一个由括号和整数组成的字符串。 空节点则用一对空括号 “()” 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。 思路：相当于前序遍历的升级，搞得花里胡哨的 /** * Definition for a binary tree node. * struct TreeNode { *
Leetcode 108. 将有序数组转换为二叉搜索树
韩豆豆小姐的博客
10-17 124
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。 本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 思路：利用二叉搜索树的性质，中序遍历是一个升序序列，按照常理，仅仅知道中序遍历是无法得到二叉树的，题目中要求二叉树的高度之差不能超过一，选择根节点的时候考虑使用中间结点 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNo
leetcode刷题手册c++版
最新发布
09-07
LeetCode刷题手册C版是一本针对程序员刷题的教材，旨在帮助他们提高编程能力、学习算法和数据结构。C语言作为一门广泛应用于系统编程和嵌入式开发的语言，在LeetCode刷题中也是非常重要的一种编程语言。 这本手册...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值