手撕代码之“链表”

最新推荐文章于 2022-08-06 23:14:10 发布
最新推荐文章于 2022-08-06 23:14:10 发布
阅读量199 收藏 1
点赞数
分类专栏： Algorithm Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31032005/article/details/107416482
版权

文章目录

删除重复链表

题目描述： 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
解题思路：
(1)新建一个指向头节点pHead的新节点Head
(2)tmp指向链表的实际头节点pHead
(3)同时需要一个pre节点来保存当前节点的前一节点的，初始化时，pre=Head;以便于删除重复节点后能连接后续的节点
分两种情况讨论：当头节点就有相同的节点的时候，此时，Head.next=tmp.next;
当相同的节点不在头节点的时候，pre=pre.next;(指向当前链表的头节点)，tmp=tmp.next;
图解算法
在这里插入图片描述

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead){
        if(pHead==null || pHead.next==null){
            return pHead;
        }
        ListNode Head=new ListNode(0);
        Head.next=pHead;
        ListNode pre=Head;
        ListNode tmp=Head.next;
        while(tmp!=null){
            if(tmp.next!=null && tmp.val==tmp.next.val){
               while(tmp.next!=null && tmp.val==tmp.next.val){
                   tmp=tmp.next;
               }
               pre.next=tmp.next;
               tmp=tmp.next;
            }else{//头节点不相同的情况
                pre=pre.next;
                tmp=tmp.next;
            }
        }
        return Head.next;
    }
}

链表中找环的入口

题目描述：
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
解题思路：
（1）使用快慢指针，fast=fast.next.next;slow=slow.next;快指针走过的路程为慢指针的两倍。如果有环，两者必然会相遇。
（2）第一次相遇后，将slow复原到pHead，fast仍然从相遇点出发，当两者以相同的速读再次前进时，下一次相遇点则为环的起点。

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode EntryNodeOfLoop(ListNode pHead){
        if(pHead==null || pHead.next==null){
            return null;
        }
        ListNode slow=pHead;
        ListNode fast=pHead;
        while(fast!=null && fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
            if(slow==fast){
                break;
            }
        }
        //第一次相遇，此时让slow回到起点，slow和fast以相同的速度前行，
        //他们的再次相遇点位环的起点
        slow=pHead;
        while(slow!=fast){
            fast=fast.next;
            slow=slow.next;
        }
        //相遇，slow为环状的起点
        return slow;
    }
}

约瑟夫环问题

问题描述：
首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)
解题步骤：
（1）用java中的list集合来模拟约瑟夫环问题，模拟环状的关键在于：index%list.size();
（2）初始化index为要删除的节点前一个位置，index+m则表示为当前要删除的节点位置，删除完成节点后，需要将index–；即移动到前一个位置，便于下次循环继续删除。

import java.util.*;
public class Solution {
    public int LastRemaining_Solution(int n, int m) {
        //特判
        if(n==0 || m==0){
            return -1;
        }
        LinkedList<Integer> list=new LinkedList<Integer>();
        //创建循环链表
        for(int i=0;i<n;i++){
            list.add(i);
        }
        //表示index在头节点之前的位置
        int index=-1;
        while(list.size()>1){
            index=(index+m)%(list.size());
            list.remove(index);
            index--;//将index回到头节点之前的位置，即上一个节点
        }
        return list.get(0);
    }
}

两条链表中的公共节点

题目描述：
输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）
在这里插入图片描述

解题思路分析
（1）使用双指针方法，同时遍历两条链表。
（2）如果存在公共节点，那么，两个指针必然会相交。
（3）但是两条链表的长短不一，这种情况下，必然有一个指针会先停下来（如果没有找到公共节点），这个时候，就让这个指针指向另外一条链表的头节点，但另外一个指针也结束后，也让他指向另外一条链表。如此反复进行遍历，如果有节点，他们必将指向同一个节点。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
         if(pHead1==null && pHead2==null){
             return null;
         }
         if(pHead1==null || pHead2==null){
             return null;
         }
         ListNode p=pHead1;
         ListNode q=pHead2;
         while(p!=q){
             p=p.next;
             q=q.next;
             if(p!=q && p==null){
                 p=pHead2;
             }
             if(p!=q && q==null){
                 q=pHead1;
             }
         }
        return p;
    }
}

复制复杂的链表问题

问题描述：
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
解题思路：
由于存在Random指针，可以考虑用map将原链表中的每个节点的值保存起来。然后依次按照链表的的节点顺序从map中取出复制的节点，用于构建新的链表。分别用p、q指针指向原链表和目标链表。
直接上代码更加清晰动人

/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
import java.util.*;
public class Solution {
    public RandomListNode Clone(RandomListNode pHead){
        if(pHead==null){
            return null;
        }
        RandomListNode p = pHead;
        //新建节点
        RandomListNode target = new RandomListNode(p.label);
        RandomListNode q=target;
        HashMap<RandomListNode,RandomListNode> map=new HashMap<RandomListNode,RandomListNode>();
        //创建两条链表之间的映射关系
        while(pHead!=null){
            map.put(pHead,new RandomListNode(pHead.label));
            pHead=pHead.next;
        }
        //开始复制
        while(q!=null){
            q.next=map.get(p.next);//p点的下一个节点
            q.random=map.get(p.random);//p的random节点
            
            p=p.next;
            q=q.next;
        }
        return target;
    }
}

合并两条链表

题目描述：
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
思路分析：
(1)设置两个指针p和q分别指向两条链表，新建一条target链表用作最后的结果返回，同时给target新建一个辅助指针t:t=target
(2)比较p和q节点的值，分情况讨论，存在三种情况：

  • p.val< q.val,则t的下个节点接p
  • p.val==q.val,则t需要分别接p和q
  • p.val>q.val,则他需要接q;
    (3)最后，可能存在两条链表不一样长的情况，同时需要考虑两种情况，把长的剩余的链表直接到t的后面
    (4)最后注意是返回target.next
/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1==null && list2==null){
            return null;
        }
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
        ListNode p=list1;
        ListNode q=list2;
        ListNode target=new ListNode(-1);
        ListNode t=target;
        while(p!=null && q!=null){
            if(p.val<q.val){
                t.next=p;
                p=p.next;
                t=t.next;
            }else if(p.val==q.val){
                t.next=p;
                p=p.next;
                t=t.next;
                t.next=q;
                q=q.next;
                t=t.next;
            }else{
                t.next=q;
                q=q.next;
                t=t.next;
            }
        }
        //至少有一条链表先完成
        if(p==null){
            t.next=q;
            t=t.next;
        }else if(q==null){
            t.next=p;
            t=t.next;
        }else{
            return target.next;
        }
        return target.next;
    }
}

链表的反转

题目描述：
给定一个链表，求出该链表的反转链表
解题思路1：
在这里插入图片描述

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head==null){
            return null;
        }
       ListNode pre=null;
       ListNode cur=head;
       ListNode next=null;
       while(cur!=null){
           next=cur.next;
           //连接逆转链表
           cur.next=pre;
           //三个指针向后移动
           pre=cur;
           cur=next;
       }
        return pre;
    }
}

解题思路2：
这种方式需要耗费额外的内存（需要复制每一个节点）

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head==null){
            return null;
        }
        ListNode p=head;
        ListNode target=new ListNode(-1);
        ListNode t=target;
        while(p!=null){
            ListNode q=new ListNode(p.val);//需要复制节点
            q.next=t.next;
            t.next=q;
            // 拼接完成
            p=p.next;
            
        }
        return target.next;
    }
}

输出链表倒数第K个节点

题目描述：
输入一个链表，输出该链表中倒数第k个结点。
解题思路：
（1）注意特判情况，当链表的长度小于输入参数K时，无效
（2）设置p和q两个指针，让p先走k步，然后让p和q同步走，当q为null时，此时p所指向的节点即为倒数第k个节点

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if(count(head)<k){
            return null;
        }
        ListNode p=head;
        ListNode q=head;
        for(int i=0;i<k;i++){
            q=q.next;
        }
        while(q!=null){
            q=q.next;
            p=p.next;
        }
        return p;
    }
    private int count(ListNode head){
        if(head==null){
            return 0;
        }
        ListNode tmp=head;
        int count=0;
        while(tmp!=null){
            count++;
            tmp=tmp.next;
        }
        return count;
    }
}

从尾到头打印链表

解题思路：
（1）先反转链表，然后再遍历即可
（2）使用栈先存储链表，然后从栈中取出数据并打印；
这里以第（2）种方案为案例进行代码演示：

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.*;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> res=new ArrayList<Integer>();
        if(listNode==null){
            return res;
        }
        Stack<Integer> stack=new Stack<Integer>();
        ListNode tmp=listNode;
        while(tmp!=null){
            stack.add(tmp.val);
            tmp=tmp.next;
        }
        while(!stack.isEmpty()){
            res.add(stack.pop());
        }
        return res;
    }
}
小毅哥哥1996
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面试手撕代码整理
09-29
自己整理的在面试时可能出现的手撕代码题目，例如求一个数的平方根，反转链表，辗转相除法求最大公约数等，希望能提供一些帮助
js代码-算法之链表
07-16
js代码-算法之链表
面试手撕代码全集（链表）
weixin_44739750的博客
09-16 284
链表
常用的链表手撕代码整理
weixin_42145502的博客
08-10 254
具体参考大佬的：https://blog.csdn.net/qq_37466121/article/details/88204678 #include <iostream> #include <vector> using namespace std; struct listnode{ int val; listnode* next; //listnode(int x):val(x),next(NULL){} }; listnode * createnode(int
手撕代码之链表
青萍之末的博客
04-09 1033
文章目录一、反转链表（leetcode 206）二、两个链表的交点（leetcode 160）三、链表的中间结点（leetcode 876）四、判断链表是否存在环（leetcode 141）五、输出链表环的入口结点（leetcode 142）六、删除链表中倒数第k个节点（leetcode 19）七、合并两个排序链表（leetcode 21）八、O(1)时间删除链表中的一个结点（leetcode 2...
五道超经典题目，带你手撕链表题（多种方法实现）
Ceylan__的博客
05-06 1345
五道超经典题目，带你手撕链表题（多种方法实现）
手撕代码-反转链表
wengmq的博客
03-16 475
反转链表 node * func(node*phead) { node* cur_next; node* cur_previous = NULL; node* current = phead; while(current != NULL) { cur_next = current->pnext; current->pnext = cur_previous; c...
cpp代码-链表头文件
07-16
cpp代码-链表头文件
c++实现链表完整代码
11-07
c++实现链表完整代码，可直接使用，经测试可在c++环境下正常编译运行。
ACM模式处理输入输出大全（多组数据、数组、链表、二叉树链接整理）
qq_41667348的博客
07-27 2569
ACM模式处理输入输出（数组、矩阵、链表、二叉树）
【数据结构与算法】---OJ手撕链表题
weixin_67900732的博客
08-06 311
小编带大家学习链表OJ题。
C++链表02：反转链表
qq_43700779的博客
03-23 4489
1.背景 大家好，我是酒馆店小二。 力扣206.翻转链表。 题意：反转一个单链表。 示例: 输入: 2->3->4->5->NULL 输出: 5->4->3->2->NULL 2.迭代 如图， 定义pre指针，初始化为 nullptr； 定义cur指针，指向头结点； 定义temp指针，指向cur->next节点，为什么要指向这个节点？因为接下来要改变cur->next的指向，将cur->next指向pre; 重复执行上述操作，不断后移p
C++反转链表
qq_43314839的博客
02-18 3737
https://www.nowcoder.com/practice/75e878df47f24fdc9dc3e400ec6058ca 正规解法（反转链表，通过调整链表指针达到反转链表） 时间复杂度：O(n), 遍历一次链表 空间复杂度：O(1) /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public:
链表手撕代码（链表的创建、头插法、尾插法、部分反转、全部反转、链表的排序、链表的销毁）
cwang_running的博客
06-05 375
链表作为基础数据结构中的必考知识点，考察指针操作。为了方便后期更好地总结学习，现将链表问题简单总结如下： 链表的创建、头插法、尾插法、部分反转、全部反转、链表的排序、链表的销毁。直接上代码： #include <stdlib.h> #include<iostream> #include<ctime> #include<queue> #incl...
C++面试常考的手撕代码题型总结
HuYingJie_1995的博客
04-16 3279
最近打算总结一下C++面试常考的手撕代码，下面是总结的可能手撕代码的来源，确实有点多，不过能写出这些代码对了解底层原理和提升编程能力还是有很大帮助的。 各种常用的排序算法：冒泡、快排、插入、堆排序、希尔、基数或桶排序 查找算法：二分查找、插值查找、顺序查找 数据结构：链表、树、堆、栈、顺序表 各种字符串函数如strcmp()与strncmp() 智能指针share_ptr,weak_ptr,un...
牛客TOP101之链表篇（高效刷题，带你手撕算法）
qq_36317312的博客
05-04 2045
1、反转链表 1、给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。 如当输入链表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 以上转换过程如下图所示： 输入：{1,2,3} 返回值：{3,2,1} 输入：{} 返回值：{} 说明：空链表则输出空 常规思路：迭代 具体细节：在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个
基于 Java 实现的打砖块游戏【安卓传感器开发课程实验】
最新发布
06-28
【作品名称】：基于 Java 实现的打砖块游戏【安卓传感器开发课程实验】 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：打砖块游戏，安卓传感器开发课程实验
HTML+CSS+JS+JQ+Bootstrap的服务信息展示响应式手机网页模板.7z
06-28
解锁网页开发秘籍，这套源码集成了HTML的结构力量、CSS的视觉魔法、JavaScript的交互智慧、jQuery的效率工具箱及Bootstrap的响应式盔甲。从基础搭建到动态交互，一步到位。 HTML筑基，强化网页骨络； CSS妆点，让设计灵动多彩； JavaScript驱动，实现页面互动； jQuery加持，简化操作，加速开发； Bootstrap响应，适配多端，无缝浏览。 无论你是编程新手还是高手，这份资源都能带你深入前端世界的核心，实践中学以致用，创造既美观又强大的网页作品。立刻行动，激发你的前端创造力！
手撕list链表底层
11-16
手撕List链表底层涉及到一些计算机科学和数据结构的知识，包括链表、节点、内存管理等。下面是对手撕List链表底层的一些基本介绍： 1. 链表结构：链表是由一系列节点组成的数据结构，每个节点包含数据和指向下一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值