算法通关村第一关——链表经典问题

最新推荐文章于 2024-05-30 20:15:33 发布
最新推荐文章于 2024-05-30 20:15:33 发布
阅读量925 收藏
点赞数
文章标签： 算法 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60895874/article/details/131837675
版权

内容

在这里插入图片描述

链表的定义

         class ListNode {
            int val;
            ListNode next;  
            
            ListNode(int val) {
                this.val = val;
            }
        }

找到两个链表第一个公共子节点

剑指office 52题
在这里插入图片描述

public class 链表相交 {
    class Solution {
        //1. 哈希集
/*        public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
            Set<ListNode> set = new HashSet<>();
            while (headA != null) {
                set.add(headA);
                headA = headA.next;
            }
            while (headB != null) {
                if (set.contains(headB)) {
                    return headB;
                }
                headB = headB.next;
            }
            return headB;
        }*/

        //2. 栈
             /*   public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
                    Stack<ListNode> a=new Stack<>();
                    Stack<ListNode> b=new Stack<>();
                    ListNode pre=null;
                    while(headA!=null){
                        a.push(headA);
                        headA=headA.next;
                    }
                    while(headB!=null){
                        b.push(headB);
                        headB=headB.next;
                    }
                    while(a.size()>0 &&b.size()>0){
                        if(a.peek()==b.peek()){
                            pre=a.pop();
                            b.pop();
                        }else{
                            break;
                        }
                    }
                    return pre;
        }
*/

        //3.双指针
     /*   public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
              if ( headA== null ||  headB== null) {
            return null;
        }
        ListNode p1 =headA ;
        ListNode p2 =headB ;
        while (p1 != p2) {
            p1 = p1.next;
            p2 = p2.next;
            //不加上，如果没有相同结点就死循环了
            if (p1 != p2) {
                if (p1 == null) {
                    p1 =headB ;
                }
                if (p2 == null) {
                    p2 =headA ;
                }
            }
        }
        return p1;

    }*/

        //4. 差和双指针
        //因为公共只会出现在较短的链表中，所以让它们一起开始遍历;
        public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
            if (headA == null || headB == null) {
                return null;
            }
            ListNode pre1 = headA;
            ListNode pre2 = headB;
            int len1 = 0, len2 = 0;
            while (pre1 != null) {
                len1++;
                pre1 = pre1.next;
            }
            while (pre2 != null) {
                len2++;
                pre2 = pre2.next;
            }
            //一样长的无变化
            int sub = len1 > len2 ? len1 - len2 : len2 - len1;
            pre1 = headA;
            pre2 = headB;
            if (len1 > len2) {
                //长的先走sub步
                for (int i = 0; i < sub; i++) {
                    pre1 = pre1.next;
                }
            }
            if (len2 > len1) {
                //长的先走sub步
                for (int i = 0; i < sub; i++) {
                    pre2 = pre2.next;
                }
            }
            while (pre1 != pre2) {
                pre1 = pre1.next;
                pre2 = pre2.next;
            }
            return pre1;

        }
    }
}

判断链表是否为回文序列

LeetCode234题
在这里插入图片描述

public class 回文链表 {
    class Solution {
        //1. 栈
    /*
    public boolean isPalindrome(ListNode head) {
   ListNode temp=head;
   Stack<Integer> stack=new Stack<>();
   int len=0;
   while(temp!=null){
       stack.push(temp.val);
       temp=temp.next;
       len++;
   }
   while(stack.size()>=len/2 &&head!=null){
       if(head.val!=stack.pop()){
return false;
       }
       head=head.next;
   }
   return true;
    }
    */

        //2.快慢指针

        public boolean isPalindrome(ListNode head) {
            if (head == null || head.next == null) {
                return true;
            }
            //slow和fast是快慢指针，slow到一半，fast到结尾了，prepre指针作用是不断翻转前一半的链表，pre最后会变成中间结点的前一个结点，因为中间结点一定相同，然后处在中间的slow往右移到一个单位，就能开始和pre指针的遍历比较了。
            ListNode slow = head, fast = head;
            ListNode pre = head, prepre = null;
            while (fast != null && fast.next != null) {
                pre = slow;
                slow = slow.next;
                fast = fast.next.next;
                pre.next = prepre;
                prepre = pre;
            }
            if (fast != null) {
                slow = slow.next;
            }
            while (pre != null && slow != null) {
                if (pre.val != slow.val) {
                    return false;
                }
                pre = pre.next;
                slow = slow.next;
            }
            return true;
        }

        //Definition for singly-linked list.
        public class ListNode {
            int val;
            ListNode next;

            ListNode() {
            }

            ListNode(int val) {
                this.val = val;
            }

            ListNode(int val, ListNode next) {
                this.val = val;
                this.next = next;
            }
        }

    }
}

合并两个有序链表

LeetCode 21
在这里插入图片描述

class Solution {

    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        //方法1:
   /*     ListNode newHead = new ListNode(-1);
        ListNode res = newHead;
        while (list1 != null && list2 != null) {
            if (list1.val < list2.val) {
                newHead.next = list1;
                list1 = list1.next;
            } else if (list1.val > list2.val) {
                newHead.next = list2;
                list2 = list2.next;
            } else { //相等的情况，分别接两个链
                newHead.next = list2;
                list2 = list2.next;
                newHead = newHead.next;
                newHead.next = list1;
                list1 = list1.next;
            }
            newHead = newHead.next;

        }
        while (list1 != null) {
            newHead.next = list1;
            list1 = list1.next;
            newHead = newHead.next;
        }
        while (list2 != null) {
            newHead.next = list2;
            list2 = list2.next;
            newHead = newHead.next;
        }
 /*       
 //最开始没有一点优化的版本       
 /* ListNode pre=new ListNode(-1);
    ListNode res=pre;
    while(list1!=null ||list2!=null){
        if(list1!=null &&list2!=null){
            if(list1.val<list2.val){
                pre.next=list1;
                list1=list1.next;
            }else if(list1.val>list2.val){
                pre.next=list2;
                list2=list2.next;
            }else if(list1.val==list2.val){
             pre.next=list1;
                list1=list1.next;
                pre=pre.next;
                pre.next=list2;
                list2=list2.next;
            }
            pre=pre.next;
        }else if(list1==null &&list2!=null){
             pre.next=list2;
                list2=list2.next;
                pre=pre.next;
        }else if(list1!=null &&list2==null){
               pre.next=list1;
                list1=list1.next;
                pre=pre.next;
        }
    }  
    return res.next;*/


        //方法2:优化方法1
  /*  ListNode l1=list1;
    ListNode l2=list2;
           ListNode prehead = new ListNode(-1);
        ListNode prev = prehead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }
        // 最多只有一个还未被合并完，直接接上去就行了,这是链表合并比数组合并方便的地方
        prev.next = l1 == null ? l2 : l1;
        return prehead.next;   */

        //方法3:递归
        ListNode l1 = list1;
        ListNode l2 = list2;
        if (l1 == null) {
            return l2;
        }
        if (l2 == null) {
            return l1;
        }
        if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

合并K个升序链表

LeetCode 23

class Solution {
  public ListNode mergeKLists(ListNode[] lists) {
        ListNode res = null;
        for (ListNode list : lists) {
            res = mergeTwoListsMoreSimple(res, list);
        }
        return res;
    }
        public static ListNode mergeTwoListsMoreSimple(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);
        ListNode prev = prehead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }
        // 最多只有一个还未被合并完，直接接上去就行了,这是链表合并比数组合并方便的地方
        prev.next = l1 == null ? l2 : l1;
        return prehead.next;
    }
}

合并两个链表

LeetCode 1669
在这里插入图片描述

class Solution {
    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
        ListNode pre1=list1;
        ListNode pre2=list1;
        ListNode pre3=list2;
        int i=0,j=0;
        //j<b 防止i==a-1，j==b时候，循环出不去了；
        while(pre1!=null &&pre2!=null &&j<b){
            //到a前面一个结点
          if(i!=a-1){
              pre1=pre1.next;
              i++;
          }
          //到b
          if(j!=b){
              pre2=pre2.next;
              j++;
          }
        }
        pre2=pre2.next;
        //到list2最后
        while(pre3.next!=null){
 pre3=pre3.next;
        }
        //链1尾链住2头，链2尾接链1后半部分的头
        pre1.next=list2;
        pre3.next=pre2;
        return list1;
    }
}

链表的中间结点

LeetCode 876
在这里插入图片描述

class Solution {
    //快慢指针
    public ListNode middleNode(ListNode head) {
    ListNode pre1=head;
    ListNode pre2=head;
    while(pre2!=null && pre2.next!=null){
             pre1=pre1.next;
             pre2=pre2.next.next;
    }
    return pre1;
    }
}

链表中倒数第k个节点

剑指 Offer 22
在这里插入图片描述

class Solution {
    //假设有五个结点，找倒数第二个，那么它就是正数第四个结点，想达到这个目标只需要走n-k步，也就是5-2=3步即可，因为走到最后那个位置要n步，所以我让快指针先走k步（2步），到达正数第三个位置，然后还有三步两个一起走n-k步即可;
    public ListNode getKthFromEnd(ListNode head, int k) {
   ListNode pre1=head;
   ListNode pre2=head;
   while(pre1!=null&& k>0){
       pre1=pre1.next;
       k--;
   }
   while(pre1!=null){
       pre2=pre2.next;
       pre1=pre1.next;
   }
   return pre2;

    }
}

旋转链表

LeetCode 61
在这里插入图片描述

//双指针找到倒数第k个位置，分成123和45两个序列，快指针先走k步，然后一起走，快指针到尾部时候，慢指针到了倒数第k个结点的前一个结点，也就是3，将4赋值给res后，3指向null，快指针代表的5也指向了头结点1，完成了旋转，最后是45123;
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
 if (head == null || k == 0) {
            return head;
        }
        ListNode temp = head;
        ListNode fast = head;
        ListNode slow = head;
        int len = 0;
        while (head != null) {
            head = head.next;
            len++;
        }
        if (k % len == 0) {
            return temp;
        }
        while ((k % len) > 0) {
            k--;
            fast = fast.next;
        }
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        ListNode res = slow.next;
        slow.next = null;
        fast.next = temp;
        return res;
    }
}

删除指定结点

LeetCode 203
在这里插入图片描述

class Solution {
    public ListNode removeElements(ListNode head, int val) {

//方法1:
//如果要删除的值为val的是头结点,可能新的头结点值也为val,题目要求
//删除所有值为val的,所以使用while循环;
while(head!=null && head.val==val){
    head=head.next;
}
if(head==null){
    return head;
}
ListNode prev=head;
while(prev.next!=null){
if(prev.next.val==val){
             prev.next=prev.next.next;
         }else{
             prev=prev.next;
         }
}
return head;

//方法2:虚拟头结点
 /*    ListNode dNode=new ListNode(val-1);
     dNode.next=head;
     ListNode prev=dNode;
     //共用一个内存了
     while(prev.next!=null){
         if(prev.next.val==val){
             prev.next=prev.next.next;
         }else{
             prev=prev.next;
         }
     }
     return dNode.next;  */
    }
}

删除链表的倒数第 N 个结点

LeetCode 19
在这里插入图片描述

class Solution {
    //方法1:双指针,因为这次要删倒数第k个，要找前一个，所以从虚拟结点开始;
    //建立头结点，方便删除第一个结点
  /*  public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode pre1=head; 
    ListNode pre3=new ListNode(0);
    pre3.next=head;
    ListNode pre2=pre3;
    while(pre1!=null && n>0){
     n--;
     pre1=pre1.next;
    }
     while(pre1!=null){
     pre2=pre2.next;
     pre1=pre1.next;
    }
    pre2.next=pre2.next.next;
    return pre3.next;
    }  */

    //方法2：利用栈
    public ListNode removeNthFromEnd(ListNode head, int n) {
 // ListNode pre1=head; 
    ListNode pre3=new ListNode(0);
    pre3.next=head;
    ListNode pre2=pre3;
    Stack<ListNode> stack=new Stack<>();
    while(pre2!=null){
        stack.push(pre2);
        pre2=pre2.next;
    }
    for(int i=0;i<n;i++){
        stack.pop();
    }
    //此时栈顶就是倒数第n个结点的前一个结点
     pre2 = stack.peek();
pre2.next=pre2.next.next;
return pre3.next;
    }
}

删除排序链表中的重复元素（保留一个）

LeetCode 83
在这里插入图片描述

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
          if(head==null){
              return head;
          }
          ListNode pre=head;
          while(pre.next!=null){
              if(pre.val==pre.next.val){
                  pre.next=pre.next.next;
              }else{
                  pre=pre.next;
              }
          }
          return head;
    }
}

删除排序链表中的重复元素（重复元素都不要）

LeetCode 82
在这里插入图片描述

class Solution {
    //因为有删头结点的可能性,所以设置虚拟头结点
    public ListNode deleteDuplicates(ListNode head) {
 ListNode pre=new ListNode(0);
 pre.next=head;
  ListNode cur=pre;
  while(cur.next!=null &&cur.next.next!=null){
      if(cur.next.val == cur.next.next.val){
          int x=cur.next.val;
          //这个while作用是一次性把重复的删干净
          while(cur.next!=null &&cur.next.val==x){
              cur.next=cur.next.next;
          }
          }else{
              cur=cur.next;
          }
      }
        return pre.next;
  }

    }
Justhavefun！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
算法通关村第一关-链表青铜挑战笔记
10-28
源代码
Python实现数据结构与算法——反转链表
12-21
题目描述： 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道...这个过程相当于，在遍历链表的过程中，每一个当前节点的nex
算法通关村第一关——链表经典问题笔记
m0_73550910的博客
10-22 323
优化2：双指针，fast一次走两步，slow一次走一步。当fast到达表尾时，slow刚好指向中间位置，这是可以开始逆序一般半的元素，按照优化一比较。优化1：只需要反转一半元素，先遍历一遍，得到总长度。然后重新遍历，到达一半时不是进行反转，而是比较两个链表。方法1：反转链表法：将原始链表元素值逆序保存到新创建的链表中，然后重新遍历两个链表，比较元素的值。
算法通关村第一关——链表经典问题之合并有序链表
weixin_47474875的博客
07-26 102
链表经典问题之合并两个有序链表
算法通关村第一关——链表经典问题之回文链表
V_i_n_g的博客
08-28 66
重点要关注回文链表的特点:从前往后和从后往前遍历的效果都一样。的特性可以利用，选择。
算法通关村第一关——链表经典问题之双指针笔记
weixin_52397263的博客
10-26 87
链表双指针专题 1寻找中间结点 2寻找倒数第K个元素 3旋转链表 公共子节点双指法
算法通关村第一关——链表经典问题之ALLIN笔记
m0_63497607的博客
08-31 197
两个链表的头结点都是已知的，相交之后成为一个单链表，但是相交的位置未知，并且相交之前的结点数也是未知的，请设计算法找到两个链表的合并点。双指针，这里用快慢指针，快指针停下的时候，如果下一个结点不为空，就返回慢指针下一个结点。如果为空，就返回慢指针。栈：虽然两个链表长度不等，但是后面的结点是一致的，所以根据栈先进后出的特点，将两个链表压入两个栈中，先出的都是一致的结点，最晚出的就是第一个公共子节点。介绍：将两个升序链表合并为一个新的升序链表并返回，新链表是通过拼接给定的两个链表的所有结点组成的。
算法通关村第一关——链表经典问题之公共子节点笔记
KrisAlthea的博客
12-05 373
链表经典问题之公共子节点
算法通关村第一关——链表经典问题之白银挑战笔记
retgog的博客
07-18 306
1、先遍历链表得到长度len，k=k%len，需要将进行链表拼接，先寻找旋转后的头结点，fast先走k步，slow与fast再同时走，fast.next走到null时，slow走到倒数第k+1个元素，即旋转后头结点前一个结点，获取slow.next结点（旋转后头结点post），slow.next=null,fast.next=head,返回post。1、创建一个新链表，将两个有序链表进行遍历，比较val值，将更小的结点接入新链表，相同则都接入新链表，一个链表遍历完后，将另一个链表剩下部分都接入新链表。
算法通关村第一关——链表经典问题之回文序列笔记
weixin_47474875的博客
07-26 99
判断链表是否是回文序列
算法通关村第一关——链表经典问题之双指针专题笔记
m0_73071896的博客
10-19 619
我们可以使用快慢指针，让fast先遍历到k+1的结点位置，slow仍然在第一个位置，此时slow和fast就相差了k个结点，此时slow和fast同步走，当fast到达链表的结尾空结点时，slow所指向的就是倒数第k个元素。对于寻找链表中间结点的问题，我们可以用快慢指针来解决，一个slow指针和一个fast指针一起遍历链表，slow走一步，fast走两步，当fast在处于链表的尾部的时候，slow也就处于中间的位置了。把快指针指向的节点连到原链表头部，慢指针指向的节点断开和下一节点的联系。
C语言——链表的归并_c语言链表详解
12-21
用c语言写链表归并
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 545
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
算法训练营day41
stmfresher的博客
05-27 387
动态规划理论基础（主要就是确定动态规划的几个步骤）
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
最新发布
2201_75456895的博客
05-30 1185
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 741
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
图形学初识--空间变换
航行的土豆的博客
05-29 877
介绍二维和三维下的变换矩阵以及常见的推导和理解方式。主要就是：平移、旋转、缩放
哈希表设计与实现——链表法
05-10
链表法是一种解决哈希表碰撞问题的方法。具体来说，对于哈希表中的每个桶，可以使用一个链表来存储所有映射到该桶的键值对。如果发生碰撞，只需要将新的键值对添加到链表的末尾即可。 下面是一个使用链表法实现哈希...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值