hot100-链表相关

最新推荐文章于 2024-09-24 18:06:35 发布
最新推荐文章于 2024-09-24 18:06:35 发布
阅读量169 收藏
点赞数 1
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qazwsxxxxxasd/article/details/137051727
版权

160. 相交链表

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //让2个指针走一样的距离，消除步行差，那就一定可以一起走到相交点
        //链表A： a+c, 链表B : b+c. a+c+b = b+c+a 。则会在公共处c起点相遇。
        //若不相交，a+c+b+c = b+c+a+c 。因此相遇处是NULL

        //边界条件判断
        if(headA==null||headB== null) return null;
        ListNode cur_a =headA,cur_b =headB;
        while(cur_a!=cur_b)
        {
            if(cur_a!=null)
                cur_a=cur_a.next;
            else
                cur_a=headB;
            if(cur_b!=null)
                cur_b=cur_b.next;
            else
                cur_b=headA;

        }
        return cur_b;
    }
}

206. 反转链表

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null)  return null;
        ListNode pre = null;
        ListNode cur = head;
        while(cur!=null)
        {
            ListNode latter = cur.next;
            cur.next=pre;
            //更新下一轮状态
            pre=cur;
            cur=latter;
        }
        return pre;

}
}

234. 回文链表

class Solution {
    public boolean isPalindrome(ListNode head) {
        //回文链表 第一思路双指针
        //把值存到数组，用双指针
        ListNode cur= head;
        List<Integer> arr = new ArrayList<>();
        while(cur!=null)
        {
            arr.add(cur.val);
            cur=cur.next;
        }
        int front =0;
        int end=arr.size()-1;
        while(front<end)
        {
            if(!(arr.get(front).equals(arr.get(end))))
                return false;
            front++;
            end--;
        }
        return true;
    }
}

141. 环形链表

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null||head.next==null) return false;
        //当一个链表有环时，快慢指针都会陷入环中进行无限次移动，
        //然后变成了追及问题。想象一下在操场跑步的场景，只要一直跑下去，快的总会追上慢的
        ListNode slow =head;
        ListNode fast = head.next;//不能fast也等于head,不然while循环都进不去
        while(fast!=slow)
        {
            if(fast==null||fast.next==null) return false;
            slow=slow.next;
            fast=fast.next.next;
        }
        return true;
        
    }
}

142. 环形链表 II

public class Solution {
    public ListNode detectCycle(ListNode head) {
        //寻找环入口---双指针
        //龟兔赛跑，如果存在环，fast指针肯定能追上slow,与之相遇
        //第一次相遇 distance: fast=2low fast比slow多走n个环
        //fast-slow =nb(b为环长度) slow=nb fast =2nb
        //环入口为a+nb,即slow再走a步 
        //如何再走a步 fast回起点 同时一步步走再相遇即是环入口
       //if(head==null||head.next==null)  return null; 
       ListNode fast=head;
       ListNode slow=head;
       while(true)
       {
        if(fast==null||fast.next==null) return null;
        slow=slow.next;
        fast=fast.next.next;
        if(fast==slow)  break;
       }
       //第一次相遇完毕
       //再让slow走a步
       fast=head;
       while(true)
       {
        if(fast==slow)  break;
        slow=slow.next;
        fast=fast.next;
        //if(fast==slow)  break;
       }
       return slow;
}
}

143. 重排链表

class Solution {
    public void reorderList(ListNode head) {
        //利用线性表存储该链表，
        //然后利用线性表可以下标访问的特点，直接按顺序访问指定元素，重建该链表即可。
        ArrayList<ListNode> list = new ArrayList<>();
        ListNode cur = head;
        while(cur!=null)
        {
            list.add(cur);
            cur=cur.next;
        }
        int i =0,j=list.size()-1;
        while(i<j)
        {
            list.get(i).next=list.get(j);
            i++;
            list.get(j).next=list.get(i);
            j--;
        }
        list.get(i).next=null;
    }
}

21. 合并两个有序链表

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
            ListNode dummy =new ListNode(-1);
            ListNode pre = dummy;
            ListNode l1=list1,l2=list2;
            if(l1==null)    return l2;
            if(l2==null)    return l1;
            while(l1!=null&&l2!=null)
            {
                if(l1.val<l2.val)
                {
                    pre.next=l1;
                    l1=l1.next;
                }
                else
                {
                    pre.next=l2;
                    l2=l2.next;
                }
                pre=pre.next;
            }
            pre.next=(l1==null)?l2:l1;
            return dummy.next;
    }
}

2. 两数相加

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(-1);
        ListNode pre =dummy;
        int num1,num2,carry=0;
        //int count=1;
        while(l1!=null||l2!=null)
        {
            num1=(l1==null)?0:l1.val;
            num2=(l2==null)?0:l2.val;
            int num =(num1+num2+carry)%10;
            carry=(num1+num2+carry)/10;
            
            pre.next=new ListNode(num);

            pre=pre.next;
            if(l1!=null)
                l1=l1.next;
            if(l2!=null)
                l2=l2.next;
        }
        if(carry==1)
            pre.next= new ListNode(carry);
        return dummy.next;

    }
}

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

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //经典双指针
        ListNode dummy =new ListNode(-1,head);
        //dummy.next=head;
        if(head==null)  return null;
        ListNode slow=dummy,fast=dummy;
        for(int i=0;i<n;i++)
        {   
            fast=fast.next;
        }
        while(fast.next!=null)
        {
            slow=slow.next;
            fast=fast.next;
        }
        slow.next=slow.next.next;
        return dummy.next;

    }
}

24. 两两交换链表中的节点

class Solution {
    public ListNode swapPairs(ListNode head) {
        //递归实现
        //递归终止条件
        if(head==null||head.next==null)  return head;

        //递归体
        ListNode newHead = head.next;
        head.next=swapPairs(newHead.next);
        newHead.next=head;

        //返回值
        return newHead;

    }
}

25. K 个一组翻转链表

很经典的题目了

148. 排序链表

本质就是递归归并，不断排序两个链表，其中可以参考21. 合并两个有序链表

class Solution {
    public ListNode sortList(ListNode head) {
        //边界条件
        if(head==null||head.next==null) 
            return head;
        //归并排序
        //分割cut----找链表中点--快慢指针找
        ListNode fast=head.next;
        ListNode slow=head;
        //快慢指针找中点
        while(fast!=null&&fast.next!=null)
        {
            slow=slow.next;
            fast=fast.next.next;
        }
        ListNode tmp = slow.next;
        //断开链表
        slow.next=null;
        //递归,递归返回的过程就是归并的过程
        ListNode left =sortList(head);
        ListNode right =sortList(tmp);
        ListNode ans_head = new ListNode(0);
        ListNode cur =ans_head;
        //排序链表
        while(left!=null&&right!=null)
        {
            if(left.val<right.val)
            {
                cur.next=left;
                left=left.next;
            }
            else
            {
                cur.next=right;
                right=right.next;
            }
            cur=cur.next;

        }
        if(left!=null)
            cur.next=left;
        if(right!=null)
            cur.next=right;
        return ans_head.next;

    }
}

23. 合并 K 个升序链表

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
       ListNode ans = null;
       for(ListNode list:lists)
            ans = merge_two_Lists(ans,list);
        return ans;
    }
    private ListNode merge_two_Lists(ListNode l1,ListNode l2)
    {
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        while(l1!=null&&l2!=null)
        {
            if(l1.val<l2.val)
            {
                cur.next=l1;
                l1=l1.next;
            }
            else
            {
                cur.next=l2;
                l2=l2.next;
            }
            cur=cur.next;

        }
        cur.next=(l1==null)?l2:l1;
        return dummy.next;
    }
}

146. LRU 缓存

class LRUCache {
    //采取哈希链表 哈希表查找快，但是数据无固定顺序；链表有顺序之分，插入删除快，但是查找慢。
    private final Map<Integer,Integer> cache =new LinkedHashMap<Integer,Integer>();
    private final int capacity;
    public LRUCache(int capacity) {
        this.capacity=capacity;

    }

    //抽出来（删除一个节点）放最上面（链表添加一个节点）
    public int get(int key) {
        if(!cache.containsKey(key))
            return -1;
        //删除一个节点
        int value = cache.remove(key);
        //放在最上面，就是尾部
        //只能从尾部插入，也就是说靠尾部的数据是最近使用的，靠头部的数据是最久为使用的。
        cache.put(key,value);
        return value;
    }


    //一摞书，放入一本新书，如果已经有，把它抽出来放最上面
    public void put(int key, int value) {
        if(cache.remove(key)!=null)
        {
            cache.put(key,value);
            return;
        }
        if(cache.size()==capacity)
        {
            int old_key=cache.keySet().iterator().next();
            cache.remove(old_key);//移除最久未使用key
        }
        cache.put(key,value);

    }
}
吃完有点累
关注
Hot100-链表
m0_50696252的博客
05-27 967
请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。中（从头节点开始）跳到交叉节点的节点数。
leetCode-hot100-链表专题
m0_49074706的博客
06-19 1100
leetCode-hot100-链表专题
力扣hot100-链表
分享技术，分享经验
07-05 549
因为 HashSet 使用的是对象的引用进行比较，所以如果两个节点是同一个节点（即内存地址相同）,HashSet 会检测到这个重复的引用，从而判断链表中存在环。创建一个虚拟头节点，通过计算链表长度找到要删除节点的前一个节点，然后将其指向删除节点的下一个节点，从而实现删除倒数第 n 个节点，其中链表长度通过单独的方法计算得出。思路是通过遍历两个链表，计算对应节点值与进位的和，处理进位并构建新链表，最后返回不含虚拟头节点的结果链表。节点，最终返回处理后的链表，其中虚拟头节点用于统一处理可能的边界情况。
hot100 - 链表（上）
IT OR 考公？
04-06 836
相交链表，反转链表，回文链表，环形链表，环形链表II，合并两个有序链表
leetcode-hot100-链表部分
qq_41784433的博客
10-07 329
文章目录[2. 两数相加 - 力扣（LeetCode） (leetcode-cn.com)](https://leetcode-cn.com/problems/add-two-numbers/)[19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode） (leetcode-cn.com)](https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/)[21. 合并两个有序链表 - 力扣（LeetCode） (leetcode
hot100 -- 链表（中）
IT OR 考公？
04-16 719
两数相加，删除链表倒数第 N 个节点，两两交换链表中的节点，K 个一组翻转链表
hot100-7-链表1
weixin_48268093的博客
07-31 174
160相交链表，206反转链表，234回文链表，141环形链表，142环形链表2
Leetcode热题Hot100-链表题综合
weixin_42127177的博客
11-09 1372
2-两数相加 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 提示： 每个链表的节点数在范围[1,100]内 0<=Node.val<=9 题目数据保证列表表示的数字不含前导零 解题思路 由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。 我们同时遍历两个链表，逐位计算
hot100 -- 链表（下）
IT OR 考公？
04-28 871
随机链表的复制，排序链表，合并 K 个升序链表，LRU 缓存
leetcode数组下标大于间距-leetcode-hot100:leetcode-hot100-python
06-30
leetcode-hot100 leetcode-hot100-python 关键词与解题思路（实时更新） Hot100 按出现频率排序—解题思路 review 1-10 两数之和。Hashmap，空间换时间，扩展：on 时间复杂度寻找两数之差等于定值，用在求子数组和为...
记录算法刷题过程 主要题目类型为leetcode hot100 动态规划 二叉树 单调栈 递归 链表 数组 贪心算法等
08-14
记录算法刷题过程 主要题目类型为leetcode hot100 动态规划 二叉树 单调栈 递归 链表 数组 贪心算法等
力扣Hot100-148排序链表（插入排序/归并排序）
qq_52241267的博客
07-16 1051
给你链表的头结点head，请将其按排列并返回。[1,2,3,4]head = [][]方法一：插入排序，但是由于链表是无序的，插入排序在最坏情况下的时间复杂度是 O(n^2)，这对于较大的输入会导致超时插入排序思想，依次对未排序的节点插入到已经有序的链表中你可以在O(nlogn)时间复杂度和常数级空间复杂度下，对链表进行排序吗方法二：归并排序归并排序在链表排序中表现良好，归并排序（Merge Sort）是一种基于分治法的排序算法，具有稳定的排序表现，时间复杂度为 O(nlog⁡n)。
LeetCode 热题 HOT 100--java
qq_27348093的博客
12-13 297
1. 两数之和 给定一个整数数组 nums和一个整数目标值 target，请你在该数组中找出 和为目标值 target的那两个整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 使用map求解： class Solution { public int[] twoSum(int[] nums, int target) { Map<Integer,Integer> h...
数据结构2——单链表
weixin_73629886的博客
09-23 1156
了解了顺序表的不足，下面我们就来学习一下链表，看一看链表能不能解决顺序表的不足。
数据结构：二叉树（2）
2303_78940834的博客
09-21 1277
普通的树的实用价值比较小，将树更一步特殊化成二叉树，将获得更多的特殊性质。例如搜索二叉树，红黑树等。这篇博文主要介绍二叉树的基础知识，进阶版高级二叉树，后续会持续更新。
【数据结构取经之路】图解红黑树
bit_pan的博客
09-20 876
AVL-tree之外，另一个颇具历史且被广泛使用的平衡二叉搜索树是红黑树(RB-tree)，这名字听起来除了很抽象外，还颇具大哥味哈，会不会很难？客观地说，难度是有的，下面我们细细道来。//结点的颜色//红黑树结点的定义//结点的左孩子//结点的右孩子//结点的父节点//结点的颜色T _data;//结点的数据域{}以上就是红黑树节点定义，但有两个问题：为什么需要指向父节点的指针？为什么要将结点的默认颜色设置成黑色？先来回答第一个问题，在旋转时需要访问父节点，所以引入了指向父节点的指针。
代码随想录算法训练营 | 二叉树理论基础
jiabao0520的博客
09-22 537
训练营：二叉树理论基础
浙大数据结构：05-树9 Huffman Codes
最新发布
qq_74924951的博客
09-24 727
这道题难度挺大，我依然使用了STL库，使得代码量大幅减少不过百行
C语言-链表-添加到链表尾部
11-27
以下是C语言中将新节点添加到链表尾部的示例代码： ```c #include #include // 定义链表结构体 struct Node { int data; struct Node* next; }; // 在链表尾部添加新节点 void append(struct Node** head_ref...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值