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

青云游子

已于 2023-11-22 07:57:55 修改

阅读量107

点赞数

分类专栏：算法文章标签：算法链表笔记

于 2023-11-20 16:05:05 首次发布

本文链接：https://blog.csdn.net/qq_40382400/article/details/134480644

版权

算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

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

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

分析 :

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

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

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

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

哈希

import java.util.*;
/*
public class ListNode {
    int val;
    ListNode next = null;
    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        
        HashSet<ListNode> set = new HashSet<>();
        while(pHead1 != null){
            set.add(pHead1);
            pHead1 = pHead1.next;
        }
 
        while(pHead2 != null){
            if(set.contains(pHead2)){
                return pHead2;
            }
            pHead2 = pHead2.next;
        }
        return null;
   } 
}

栈

import java.util.*;
/*
public class ListNode {
    int val;
    ListNode next = null;
    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
 
    //创建栈
    Stack<ListNode> p1 = new Stack<>();
    Stack<ListNode> p2 = new Stack<>();
 
    //压入栈
    while(pHead1 != null){
        p1.push(pHead1);
        pHead1 = pHead1.next;
    }
    while(pHead2 != null){
        p2.push(pHead2);
        pHead2 = pHead2.next;
    }
 
    
    ListNode node = null;
    while(p1.size() > 0 && p2.size() > 0){
        if(p1.peek() == p2.peek()){
            //弹出栈
            node = p1.pop();
            p2.pop();
        }else{
            break;
        }
    }
 
        return node;
   } 
}

判断链表是否为回文序列

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

分析 :

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

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

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

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

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

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

栈(最基础版)

import java.util.*;
 
/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */
 
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 the head
     * @return bool布尔型
     */
    public boolean isPail (ListNode head) {
        // write code here
        Stack<Integer> s = new Stack<>();
        ListNode p = head;
        while(p != null){
            s.push(p.val);
            p = p.next;
        }
 
        while(head != null){
            if(head.val != s.pop()){
                return false;
            }
            head = head.next;
        }
        return true;
    }
}

合并有序链表

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

分析 :

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

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

链表(连接)

import java.util.*;
 
/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */
 
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead1 ListNode类 
     * @param pHead2 ListNode类 
     * @return ListNode类
     */
    public ListNode Merge (ListNode pHead1, ListNode pHead2) {
        // write code here
        //创建哨兵节点
        ListNode node = new ListNode(-1);
        //指向哨兵节点
        ListNode p = node;
        while(pHead1 != null && pHead2 != null){
            //连接
            if(pHead1.val <= pHead2.val){
                p.next = pHead1;
                pHead1 = pHead1.next;
            }else{
                p.next = pHead2;
                pHead2 = pHead2.next;
            }
            p = p.next;
        }
 
        //p2连接完了就剩p1因为是递增的所以直接连就行
        while(pHead1 != null){
            p.next = pHead1;
            pHead1 = pHead1.next;
            p = p.next;
        }
 
        //p1连接完了连接p2
        while(pHead2 != null){
            p.next = pHead2;
            pHead2 = pHead2.next;
            p = p.next;
        }
 
        //因为头结点是哨兵节点所以返回node.next
        return node.next;
    }
}

简化 :

import java.util.*;
 
/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */
 
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead1 ListNode类 
     * @param pHead2 ListNode类 
     * @return ListNode类
     */
    public ListNode Merge (ListNode pHead1, ListNode pHead2) {
        // write code here
        //创建哨兵节点
        ListNode node = new ListNode(-1);
        //指向哨兵节点
        ListNode p = node;
        while(pHead1 != null && pHead2 != null){
            //连接
            if(pHead1.val <= pHead2.val){
                p.next = pHead1;
                pHead1 = pHead1.next;
            }else{
                p.next = pHead2;
                pHead2 = pHead2.next;
            }
            p = p.next;
        }
 
 
        p.next = list1 == null ? list2 : list1;
 
        //因为头结点是哨兵节点所以返回node.next
        return node.next;
    }
}

合并k个已排序的链表

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

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

LCR 078. 合并 K 个升序链表

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

import java.util.*;
 
/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */
 
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param lists ListNode类ArrayList
     * @return ListNode类
     */
    public ListNode mergeKLists (ArrayList<ListNode> lists) {
        // write code here
        ListNode node = null;
        for (ListNode p : lists) {
            node = mergeTwoLists(node, p);
        }
        return node;
    }
    public ListNode mergeTwoLists(ListNode pHead1, ListNode pHead2) {
 
        //创建哨兵节点
        ListNode node = new ListNode(-1);
        //指向哨兵节点
        ListNode p = node;
        while (pHead1 != null && pHead2 != null) {
            //连接
            if (pHead1.val <= pHead2.val) {
                p.next = pHead1;
                pHead1 = pHead1.next;
            } else {
                p.next = pHead2;
                pHead2 = pHead2.next;
            }
            p = p.next;
        }
 
        p.next = pHead1 == null ? pHead2 : pHead1;
 
        return node.next;
    }
}

青云游子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法通关村第一关——链表白银挑战笔记

这是一道经典的链表问题 : 输入两个无环的，找出它们的第一个公共结点，如果没有公共节点则返回空。屡试不爽的方法: 将和常用算法思想都想一遍，看看哪些能解决问题。常用的数据结构有数组、链表、队、栈、Hash、集合、树、堆。常用的算法思想有查找、排序、双指针、递归、迭代、分治、贪心、回溯和动态规划等等。首先想到的是蛮力法，类似于冒泡排序的方式，将第一个链表中的每一个结点依次与第二个链表的进行比较，当出现相等的结点指针时，即为相交结点。虽然简单，但是时间复杂度高，排除!
复制链接

扫一扫