• 算法通关村第一关-链表白银经典问题笔记

    zhe大家好今天来写第一关的白银挑战-链表经典问题.

    两个链表的第一个公共结点

    这是一道经典的链表问题 :  输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。

    牛客NC66 :

     剑指offer56 :

    分析 : 

    屡试不爽的方法: 将常用数据结构和常用算法思想都想一遍，看看哪些能解决问题。常用的数据结构有数组、链表、队、栈、Hash、集合、树、堆。常用的算法思想有查找、排序、双指针、递归、迭代、分治、贪心、回溯和动态规划等等

    首先想到的是蛮力法，类似于冒泡排序的方式，将第一个链表中的每一个结点依次与第二个链表的进行比较，当出现相等的结点指针时，即为相交结点。虽然简单，但是时间复杂度高，排除!

    再看Hash，先将第一个链表元素全部存到Map里，然后一边遍历第二个链表，一边检测当前元素是否在Hash中，如果两个链表有交点，那就找到了。OK，第二种方法出来了。既然Hash可以，那集合呢? 和Hash一样用，也能解决，OK，第三种方法出来了。

    队列和栈呢? 这里用队列没啥用，但用栈呢?现将两个链表分别压到两个栈里，之后一边同时出栈，一边比较出栈元素是否一致，如果一致则说明存在相交，然后继续找，最晚出栈的那组一致的节点就是要找的位置，于是就有了第四种方法。

    哈希

    1. import java.util.*;
    2. /*
    3. public class ListNode {
    4.     int val;
    5.     ListNode next = null;
    7.     ListNode(int val) {
    8.         this.val = val;
    9.     }
    10. }*/
    11. public class Solution {
    12.     public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
    13.         
    14.         HashSet set = new HashSet<>();
    15.         while(pHead1 != null){
    16.             set.add(pHead1);
    17.             pHead1 = pHead1.next;
    18.         }
    19.  
    20.         while(pHead2 != null){
    21.             if(set.contains(pHead2)){
    22.                 return pHead2;
    23.             }
    24.             pHead2 = pHead2.next;
    25.         }
    26.         return null;
    27.    } 
    28. }

    栈

    1. import java.util.*;
    2. /*
    3. public class ListNode {
    4.     int val;
    5.     ListNode next = null;
    7.     ListNode(int val) {
    8.         this.val = val;
    9.     }
    10. }*/
    11. public class Solution {
    12.     public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
    13.  
    14.     //创建栈
    15.     Stack p1 = new Stack<>();
    16.     Stack p2 = new Stack<>();
    17.  
    18.     //压入栈
    19.     while(pHead1 != null){
    20.         p1.push(pHead1);
    21.         pHead1 = pHead1.next;
    22.     }
    23.     while(pHead2 != null){
    24.         p2.push(pHead2);
    25.         pHead2 = pHead2.next;
    26.     }
    27.  
    28.     
    29.     ListNode node = null;
    30.     while(p1.size() > 0 && p2.size() > 0){
    31.         if(p1.peek() == p2.peek()){
    32.             //弹出栈
    33.             node = p1.pop();
    34.             p2.pop();
    35.         }else{
    36.             break;
    37.         }
    38.     }
    39.  
    40.         return node;
    41.    } 
    42. }

     大家可以试试暴力算法和集合 , 也可以尝试其他方法 , 欢迎投稿 .

    判断链表是否为回文序列

    描述 : 给定一个链表，请判断该链表是否为回文结构。回文是指该字符串正序逆序完全一致。

    LeetCode234 : 

    牛客NC96 :

    分析 : 

    我们仍然是先将常见的数据结构和算法思想想一遍，看看谁能解决问题。

    方法1 : 我们应该能想到数组 , 将链表元素都赋值到数组中，然后可以从数组两端向中间对比。这种方法会被视为逃避链表，面试不能这么干。

    方法2 : 其次我们能想到用栈 , 将链表元素全部压栈，然后一边出栈，一边重新遍历链表，一边比较两者元素值，只要有一个不相等，那就不是。这是一种好用的方法 , 在这个方法上可以进行简化 

    方法3: 优化方法2，先遍历第一遍，得到总长度。之后一边遍历链表，一边压栈。到达链表长度一半后就不再压栈，而是一边出栈，一边遍历，一边比较，只要有一个不相等，就不是回文链表。这样可以节省一半的空间。

    方法4: 优化方法3:既然要得到长度，那还是要遍历一次链表才可以，那是不是可以一边遍历一边全部压栈，然后第二遍比较的时候，只比较一半的元素呢?也就是只有一半的元素出栈，链表也只遍历一半，当然可以

    方法5: 反转链表法，先创建一个链表newList，将原始链表oldList的元素值逆序保存到newList中，然后重新一边遍历两个链表，一遍比较元素的值，只要有一个位置的元素值不一样，就不是回文链表

    栈(最基础版)

    1. import java.util.*;
    2.  
    3. /*
    4.  * public class ListNode {
    5.  *   int val;
    6.  *   ListNode next = null;
    7.  *   public ListNode(int val) {
    8.  *     this.val = val;
    9.  *   }
    10.  * }
    11.  */
    12.  
    13. public class Solution {
    14.     /**
    15.      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
    16.      *
    17.      * 
    18.      * @param head ListNode类 the head
    19.      * @return bool布尔型
    20.      */
    21.     public boolean isPail (ListNode head) {
    22.         // write code here
    23.         Stack s = new Stack<>();
    24.         ListNode p = head;
    25.         while(p != null){
    26.             s.push(p.val);
    27.             p = p.next;
    28.         }
    29.  
    30.         while(head != null){
    31.             if(head.val != s.pop()){
    32.                 return false;
    33.             }
    34.             head = head.next;
    35.         }
    36.         return true;
    37.     }
    38. }

    大家试试数组,反转链表的方法 , 可以尝试其他方法 , 欢迎留言.

    合并有序链表

    描述 : 输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。

    LeetCode21 :

     

    牛客NC33 :

    分析 :

    解决思路与数组一样，一般有两种。一种是新建一个链表，然后分别遍历两个链表，每次都选最小的结点接到新链表上，最后排完。

    另外一个就是将一个链表结点拆下来，逐个合并到另外一个对应位置上去。这个过程本身就是链表插入和删除操作的拓展，难度不算大:

    链表(连接)

    1. import java.util.*;
    2.  
    3. /*
    4.  * public class ListNode {
    5.  *   int val;
    6.  *   ListNode next = null;
    7.  *   public ListNode(int val) {
    8.  *     this.val = val;
    9.  *   }
    10.  * }
    11.  */
    12.  
    13. public class Solution {
    14.     /**
    15.      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
    16.      *
    17.      * 
    18.      * @param pHead1 ListNode类 
    19.      * @param pHead2 ListNode类 
    20.      * @return ListNode类
    21.      */
    22.     public ListNode Merge (ListNode pHead1, ListNode pHead2) {
    23.         // write code here
    24.         //创建哨兵节点
    25.         ListNode node = new ListNode(-1);
    26.         //指向哨兵节点
    27.         ListNode p = node;
    28.         while(pHead1 != null && pHead2 != null){
    29.             //连接
    30.             if(pHead1.val <= pHead2.val){
    31.                 p.next = pHead1;
    32.                 pHead1 = pHead1.next;
    33.             }else{
    34.                 p.next = pHead2;
    35.                 pHead2 = pHead2.next;
    36.             }
    37.             p = p.next;
    38.         }
    39.  
    40.         //p2连接完了就剩p1因为是递增的所以直接连就行
    41.         while(pHead1 != null){
    42.             p.next = pHead1;
    43.             pHead1 = pHead1.next;
    44.             p = p.next;
    45.         }
    46.  
    47.         //p1连接完了连接p2
    48.         while(pHead2 != null){
    49.             p.next = pHead2;
    50.             pHead2 = pHead2.next;
    51.             p = p.next;
    52.         }
    53.  
    54.         //因为头结点是哨兵节点所以返回node.next
    55.         return node.next;
    56.     }
    57. }

    简化 : 

    1. import java.util.*;
    2.  
    3. /*
    4.  * public class ListNode {
    5.  *   int val;
    6.  *   ListNode next = null;
    7.  *   public ListNode(int val) {
    8.  *     this.val = val;
    9.  *   }
    10.  * }
    11.  */
    12.  
    13. public class Solution {
    14.     /**
    15.      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
    16.      *
    17.      * 
    18.      * @param pHead1 ListNode类 
    19.      * @param pHead2 ListNode类 
    20.      * @return ListNode类
    21.      */
    22.     public ListNode Merge (ListNode pHead1, ListNode pHead2) {
    23.         // write code here
    24.         //创建哨兵节点
    25.         ListNode node = new ListNode(-1);
    26.         //指向哨兵节点
    27.         ListNode p = node;
    28.         while(pHead1 != null && pHead2 != null){
    29.             //连接
    30.             if(pHead1.val <= pHead2.val){
    31.                 p.next = pHead1;
    32.                 pHead1 = pHead1.next;
    33.             }else{
    34.                 p.next = pHead2;
    35.                 pHead2 = pHead2.next;
    36.             }
    37.             p = p.next;
    38.         }
    39.  
    40.  
    41.         p.next = list1 == null ? list2 : list1;
    42.  
    43.         //因为头结点是哨兵节点所以返回node.next
    44.         return node.next;
    45.     }
    46. }

    这种方式很明显更高级，但是面试时很难考虑周全，如果面试的时候遇到了，建议先用上面第一种写法写出来 .

    合并k个已排序的链表

    描述 :  合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。

    LeetCode LCR 078. 合并 K 个升序链表 :

    LCR 078. 合并 K 个升序链表

    牛客NC51合并k个已排序的链表 :

     分析 : 这是一个合并有序链表的拓展题 , 只要合并有序链表会了这道题不在话下 , 两两合并加上有序合并就OK了.

    1. import java.util.*;
    2.  
    3. /*
    4.  * public class ListNode {
    5.  *   int val;
    6.  *   ListNode next = null;
    7.  *   public ListNode(int val) {
    8.  *     this.val = val;
    9.  *   }
    10.  * }
    11.  */
    12.  
    13. public class Solution {
    14.     /**
    15.      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
    16.      *
    17.      *
    18.      * @param lists ListNode类ArrayList
    19.      * @return ListNode类
    20.      */
    21.     public ListNode mergeKLists (ArrayList lists) {
    22.         // write code here
    23.         ListNode node = null;
    24.         for (ListNode p : lists) {
    25.             node = mergeTwoLists(node, p);
    26.         }
    27.         return node;
    28.     }
    29.     public ListNode mergeTwoLists(ListNode pHead1, ListNode pHead2) {
    30.  
    31.         //创建哨兵节点
    32.         ListNode node = new ListNode(-1);
    33.         //指向哨兵节点
    34.         ListNode p = node;
    35.         while (pHead1 != null && pHead2 != null) {
    36.             //连接
    37.             if (pHead1.val <= pHead2.val) {
    38.                 p.next = pHead1;
    39.                 pHead1 = pHead1.next;
    40.             } else {
    41.                 p.next = pHead2;
    42.                 pHead2 = pHead2.next;
    43.             }
    44.             p = p.next;
    45.         }
    46.  
    47.         p.next = pHead1 == null ? pHead2 : pHead1;
    48.  
    49.         return node.next;
    50.     }
    51. }

    这关就到这里 , 下一关见!

  • 相关阅读:
    金融机器学习：数据集划分与baseline模型
    什么是 Rootkit？
    python函数
    网络代码理解
    编写一个kubernetes controller
    cubemx工程更换同系列stm32芯片型号
    UGUI交互组件Toggle
    Servlet
    Oracle CPU使用率过高问题处理
    Windows10系统安装VMWare
  • 原文地址：https://blog.csdn.net/sytdsqzr/article/details/133867838