《算法通关村第一关——链表白银挑战笔记》

已于 2023-08-30 19:57:14 修改
阅读量466 收藏
点赞数 1
文章标签： 算法 链表 笔记 java
于 2023-08-30 19:51:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwquu/article/details/132574774
版权

系列文章目录

《算法通关村第一关——链表青铜挑战笔记》

一、 两个链表的第一个公共节点（剑指 Offer 52）

首先，我们要理解两个单链表第一个公共子节点有什么特点，图下图所示。

链表

特点一：两个链表的第一个公共子节点是 第一个相同的元素，提到查找相同元素，第一想到的解决方法自然就是利用 Hash表来解决

   ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //采用Hash
        HashSet<ListNode> hashset = new HashSet<>();
        ListNode listNode = headA;
        while (listNode != null) {
            hashset.add(listNode);
            listNode = listNode.next;
        }
        listNode = headB;
        while (listNode != null) {
            if (!hashset.add(listNode)) {
                return listNode;
            }
            listNode = listNode.next;
        }
        return null;
    }

特点二：从右往左看，第一个公共子节点又是最后一个相同的元素，我们只需要将两个链表逆序对比，找到第一个不同的元素，并返回上一个元素即可，将链表逆序可以利用栈的先进后出的特性

    ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //采用栈
        //声明两个栈，存储链表将其逆序
        Stack <ListNode>stackA = new Stack();
        Stack <ListNode>stackB = new Stack();
        ListNode listNode=headA;
        //分别存储两个链表
        while (listNode!=null){
            stackA.push(listNode);
            listNode=listNode.next;
        }
        listNode=headB;
        while(listNode!=null){
            stackB.push(listNode);
            listNode=listNode.next;
        }
        listNode=null;
        //寻找第一个不同的元素
        while (!stackA.isEmpty()&&!stackB.isEmpty()){
            if(stackA.peek()!=stackB.peek()){
              break;
            }
            listNode=stackA.peek();
            stackA.pop();
            stackB.pop();
        }
        return listNode;
    }

二、判断表是否为回文序列（LeetCode234）


在这里插入图片描述

将链表逆序，和原列表依次对比

    public boolean isPalindrome(ListNode head) {
        ListNode listNode=head;
        Stack<ListNode> stack = new Stack<>();
        while (listNode!=null){
            stack.push(listNode);
            listNode=listNode.next;
        }
        listNode=head;
        while (listNode!=null){
            if (stack.peek().val!=listNode.val){
                return false;
            }
            stack.pop();
            listNode=listNode.next;
        }
       return  true;
    }

观察特点，回文串就是对称相等，那么解决问题的关键就分三步走，第一步找到中点，第二步将一半逆序，第三步将两部分遍历对比，最关键一步就是 找中点

存到数组中，利用数组确定长度，找到中点

    public boolean isPalindrome1(ListNode head) {
        ArrayList<ListNode> listNodeArrayList = new ArrayList<>();
        ListNode listNode =head;
        while (listNode!=null){
            listNodeArrayList.add(listNode);
            listNode=listNode.next;
        }
        for(int i=0, j=listNodeArrayList.size()-1;i<listNodeArrayList.size()/2;i++,j--){
            if (listNodeArrayList.get(i).val!=listNodeArrayList.get(j).val){
                return false;
            }
        }
        return true;
    }

利用双指针，找到中点

  public boolean isPalindrome(ListNode head) {
		//定义快慢指针，找到中间点
        ListNode fast=head,slow=head;
        while (fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        //根据fast区分奇数偶数个节点，找到链表反转的起点
        if(fast!=null){
            slow=slow.next;
        }
		//反转链表
        ListNode pre=null,next=null;
        while (slow!=null){
            next=slow.next;
            slow.next=pre;
            pre=slow;
            slow=next;;
        }
        //对比
        while (pre!=null){
            if(pre.val!=head.val){
                return false;
            }
            pre=pre.next;
            head=head.next;
        }
        return true;
    }

三、合并有序列表

1.和并有序列表(leetcode25)

代码如下（示例）：

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode newnode=new ListNode(-1);
        ListNode temp=newnode;
        while (l1!=null&&l2!=null){
            if(l1.val<l2.val){
                newnode.next=l1;
                l1=l1.next;

            }else {
                newnode.next=l2;
                l2=l2.next;

            }
            newnode=newnode.next;
        }
        if (l1!=null){
            newnode.next=l1;
        }
        if(l2!=null){
            newnode.next=l2;
        }
        return temp.next;
    }

2.合并k个有序列表(leetcode78)

代码如下（示例）：

 public ListNode mergeKLists(ListNode[] lists) {
        ListNode ln=null;
        for(int i=0;i<lists.length;i++){
            ln=mergeKList(ln,lists[i]);
            
        }
        return ln;
    }
    public ListNode mergeKList(ListNode l1,ListNode l2){
        ListNode newnode=new ListNode(-1);
        ListNode temp=newnode;
        while(l1!=null&&l2!=null){
            if(l1.val<l2.val){
                temp.next=l1;
                l1=l1.next;
            }
            else{
                temp.next=l2;
                l2=l2.next;
            }
            temp=temp.next;
        }
        temp.next = l1==null? l2:l1;
        return newnode.next;
    }

3.一道无聊的题（leetcode1669）

    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
       ListNode temp=new ListNode(-1);
       temp.next=list1;
       int a_temp=a;
        while ((a--)>0){
            temp=temp.next;
        }
        //出现过错误，把a自减了，还用a，以后要主意呀
        int length=b-a_temp;
        
        ListNode temp1=temp;
        while ((length--)>=-1){
            temp1=temp1.next;
        }
        ListNode temp2=list2;
        while (temp2.next!=null){
            temp2=temp2.next;
        }
        temp.next=list2;
        temp2.next=temp1;
        return list1;
    }

四、双指针专题

1. 找中间节点（leetcode876）

 public ListNode middleNode(ListNode head) {
        ListNode fast=head,slow=head;
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }
        return slow;
    }

2 . 链表中倒数第k个节点(剑指 Offer 22)

乍一看这道题最简单的方法是循环两次，第一确定长度，第二次循环找到我们要的倒数第k个节点。
差k个节点就遍历完整个链表，让个一个指针先快跑k步，另一个指针在开始跑，遍历完一边后，慢的指针就是我们想要的

 public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode fast=head,slow=head;
        while(fast!=null){
            if((k--)>0){
                fast=fast.next;
            }else{
                slow=slow.next;
                fast=fast.next;
            }
        }
        return slow;
    }

3.旋转链表（leetcode61）


给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

在这里插入图片描述

输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]

首先我们要清楚k时可能要大于链表的长度的，因此我们先取余，如上图所示，k=7和k=2旋转结果是相同的
旋转k个位置就是将后k个元素接到了来年表的头部

public ListNode rotateRight(ListNode head, int k) {
        int len=0;
        //移除特殊情况
        if(head==null){
            return null;
        }
        //计算链表长度
        ListNode listnode =head;
        while(listnode!=null){
            len++;
            listnode=listnode.next;
        }  
        //得到后k个元素的k值
         k=(k)%len;   
         //找后k个元素的前一个
        ListNode fast =head,preslow=head,slow=null;
        while(fast.next!=null){
            if((k--)>0){
                fast=fast.next;
            }else{
                preslow=preslow.next;
                fast=fast.next;
            }
        }
        //成环
        fast.next=head;
        //断裂
        slow=preslow.next;
        preslow.next=null;
        
        return slow;
    }

将整个链表反转，找到分割点k，再将两部分别反转

 public ListNode rotateRight(ListNode head, int k) {
        if(head==null){
            return null;
        }
      
        int len=0;
        ListNode temp=head;
        while(temp!=null){
            temp=temp.next;
            len++;
        }
     
        k=k%len;
  		//循环到原位置，直接返回
        if(k==0){
            return head;
        }
        head=fanzhuan(head);
       temp=head;
       //把握好k的边界值
        for (int i = 0; i < k-1; i++) {
            temp=temp.next;
        }
        ListNode l1=fanzhuan(temp.next);
        temp.next=null;
        ListNode l2=fanzhuan(head);
        head.next=l1;
        return l2;
    }
    public ListNode fanzhuan(ListNode head){
        ListNode  pre=null,cur=head,next=null;
        while (cur != null) {
            next=cur.next;
            cur.next=pre;
            pre=cur;
            cur=next;
        }
        return pre;
    }

五、删除链表元素专题

1.删除特定节点（leetcode203）

使用递归

public ListNode removeElements(ListNode head, int val) {
            
         if(head==null){
             return head;
         }
         if(head.val==val){
             return removeElements(head.next,val);
         }else{
            
              head.next=removeElements(head.next,val);
              return head;
         }

           
    }

使用循环

 public ListNode removeElements(ListNode head, int val) {
            
         ListNode newnode=new ListNode(-1,head);
        
         ListNode temp=newnode;
         while(temp.next!=null){
             if(temp.next.val==val){
                 temp.next=temp.next.next;
             }else{
                  temp=temp.next;
             } 
         }
         return newnode.next;           
    }

2. 删除倒数第n个节点(leetcode19)

双指针找到倒数，第k个节点的前一个，其要考虑边界条件删除倒数第n个元素

    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode fast=head,slow=head;
        while(fast.next!=null){
            if(n-->0){
                fast=fast.next;
            }else{
                fast=fast.next;
                slow=slow.next;
            }
        }
        if(n>0){
            return head.next;
        }else{
            slow.next=slow.next.next;
            return head;
        }

    }

代码改进，加入虚拟头节点，处理删除第一个节点的情况

    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode newnode =new ListNode(-1,head);
        ListNode fast=newnode,slow=newnode;
        while(fast.next!=null){
            if(n-->0){
                fast=fast.next;
            }else{
                fast=fast.next;
                slow=slow.next;
            }
        }
            slow.next=slow.next.next;
            return newnode.next;
    }

3.删除重复节点（leetcode 83）

 public ListNode deleteDuplicates(ListNode head) {
        ListNode newnode=new ListNode(-1,head);
        ListNode temp=newnode;
        Set set=new HashSet();
        while(temp.next!=null){
            if(set.add(temp.next.val)){
                temp=temp.next;
            }else{
                temp.next=temp.next.next;
            }
        }
        return newnode.next;
    }

4.删除重复过节点(leetcode82)

   public ListNode deleteDuplicates(ListNode head) {
   		//加入虚拟头节点，方便删除第一个元素是重复节点的情况
        ListNode newnode =new ListNode(-1,head);
        ListNode temp=newnode;
        
        while(temp.next!=null){
        	//分两种情况，后继的后继为空，则一定不重复，不为空则判断是否为重复元素
            if(temp.next.next!=null){
                if(temp.next.val==temp.next.next.val){
                    int val=temp.next.val;
                    while(temp.next!=null&&temp.next.val==val){
                        temp.next=temp.next.next;
                    }
                }else{
                     temp=temp.next;
                }
            }else{
              temp=temp.next;
            }
        }
        return newnode.next;
    }

总结

`

主要介绍链表基本的操作，可以借用Hash表来解决相同重复等问题，倒转链表可以考虑栈的数据结构，巧妙的使用双指针找到中间元素，使用双指针找到倒数第k个元素

qwquu
关注
算法通关村第一关-链表青铜挑战笔记
10-28
源代码
C语言——链表的归并_c语言链表详解
12-21
标题“C语言——链表的归并_c语言链表详解”和描述“用c语言写链表归并”明确指出了本文的主要内容：使用C语言实现链表的归并操作，并对C语言中的链表进行详细讲解。 #### 代码解析 ##### 1. 结构体定义 ```c ...
Python实现数据结构与算法——反转链表
12-21
反转链表是数据结构与算法领域中的一个经典问题，它要求我们改变链表节点的指向，使得原本顺着一个方向的链表变成逆序。在这个问题中，我们可以采用两种方法来解决：迭代和递归。 首先，让我们详细讲解迭代的解题...
算法和数据结构——链表.pdf
08-07
除此之外，还有一种循环链表，它的最后一个节点指向第一个节点，形成一个环。循环链表没有头尾节点之分，所以可以方便地进行遍历操作。 在标题《算法和数据结构——链表.pdf》中提到的“算法”指的是对数据的处理...
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 576
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 376
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 868
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
生成哈夫曼树
最新发布
TTz012的博客
10-08 130
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1242
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 813
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
ICPC-day2(圆方树)
m0_74315028的博客
10-08 208
每次询问两点x, y，求是否存在一个n的排列，使得第一个元素为x，最后一个元素为y，且排列的任意一个前缀、任意一个后缀都连通。可以用圆方树缩点将其变成一颗树，再判断这颗树是否是一条链，x,y是否在这条链的两侧。其实就是求这两个点是否存在两个不相同的路径，同时两者路径的交集是n。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 808
排序是将多个数据，依指定的顺序进行排列的过程。
【旋转数组】二分法专题
weixin_45962681的博客
10-08 927
以上两道题我小总结一下，有无重复元素影响的是=加不加，其实第一题也可以加，在无重复元素的时候，开区间加不加其实没所谓，但是当有重复元素的时候，考虑这个很重要我在刚开始学习二分法的时候，背诵的模板的不加等号的if，改的是left，其实我如果照着这个模板写这两道题，就不会错，但是我鬼使神差把不加等号那边改right了，导致一直不过那么可以总结一个有无重复元素通用的模板public:= right){
【算法】---归并排序（递归非递归实现）
何春秋的博客
10-03 1173
归并排序 in Java
算法讲解—最小生成树（Kruskal 算法）
ZH_qaq的博客
10-05 1343
根据度娘的解释我们可以知道，最小生成树(Minimum Spanning Tree, MST)就是：一个有n个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有n个结点，并且有保持图连通的最少的边。简单点来说就是求最小的连通图，就是从一个点能到达图的任意一点，且花费的代价最小（所有边的权值最小）。最小生成树问题通常用于网络设计、电路设计等领域，目的是找到连接所有节点的最低成本方式。常见的算法有克鲁斯卡尔算法（Kruskal）和普里姆算法（Prim）等。
C - Separated Lunch
m0_74304371的博客
10-05 446
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
代码随想录 101. 孤岛的总面积
qq_53524614的博客
10-05 295
dfs版本，在之前求总面积的基础上增加了判断是否有有边缘位置元素的部分，所以增加了一个notEdge变量，在遇到边缘元素时标记为0，以使所有输出均变为0，此外需要注意，即使遇到了边缘元素也需要先将所有陆地遍历并在visit上标记。毕竟做人需要有始有终）bfs的版本，bfs不需要做递归回溯，所以函数的变量还是不变，只需要在内部增加一个标记是否有边缘元素的变量即可。
16.最接近的三数之和
weixin_61695887的博客
10-04 311
与三数之和的题类似，首先对数组进行排序。排序后的数组使得我们可以有效地使用双指针法来找到和最接近目标值的三元组。：遍历结束后，返回最接近的三元组的和。，然后通过双指针法来寻找另外两个数。：遍历排序后的数组，固定一个数。中选出三个整数，使它们的和与。假定每组输入只存在恰好一个解。使得三数之和最接近目标值。
国庆普及模拟赛-5
weixin_70468627的博客
10-05 372
本文为作者CSP-j国庆第5次模拟的总结
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值