算法笔记(链表)

已于 2024-08-10 11:21:08 修改
阅读量574 收藏 2
点赞数 10
分类专栏： 算法 文章标签： 算法 笔记 链表
于 2024-06-16 16:45:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64704029/article/details/139722374
版权

leetcode24 两两交换链表

public ListNode swapPairs(ListNode head) {
    ListNode dummy = new ListNode();
    ListNode cur = dummy;
    cur.next = head;
        /*
            dummy -> 1 -> 2 -> 3 -> 4
              |      |          |
            cur     temp      temp1
            要操作的数是cur之后的两个数，如果next为空则是偶数个，next的next为空是奇数个
         */
    while (cur.next != null || cur.next.next != null) {
        ListNode temp = cur.next;
        ListNode temp1 = cur.next.next.next;
        cur.next = cur.next.next;
        cur.next.next = temp;
        temp.next = temp1;
        cur = cur.next.next;
    }
    return dummy.next;
}

leetcode206 翻转链表

递归解法

public ListNode reverseList(ListNode head) {
    //递归解法
    ListNode pre = null;
    ListNode cur = head;
    return reverse(pre, cur);
}

private ListNode reverse(ListNode pre, ListNode cur) {
    if (cur == null) {
        return pre;
    }
    ListNode temp = cur.next;
    cur.next = pre;
    return reverse(cur, temp);
}

非递归解法

public ListNode ReverseList(ListNode head) {
    if (head == null || head.next == null) return head;
    ListNode pre = null;
    ListNode cur = head;
    while (cur != null) {
        ListNode next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    return pre;
}

leetcode92 翻转链表二

public ListNode reverseBetween(ListNode head, int left, int right) {
    if (head == null || left >= right) {
        return head;
    }
    ListNode dummy = new ListNode();
    dummy.next = head;
    ListNode p0 = dummy;
    //寻找规定的首结点
    for (int i = 0; i < left - 1; i++) {
        p0 = p0.next;
    }
    ListNode cur = p0.next;
    ListNode pre = null;
    for (int i = 0; i < right - left + 1; i++) {
        ListNode temp = cur.next;
        cur.next = pre;
        pre = cur;
        cur = temp;
    }
    p0.next.next = cur;
    p0.next = pre;
    return dummy.next;
}

leetcode83 删除排序链表中的重复元素

public ListNode deleteDuplicates(ListNode head) {
    if (head == null) {
        return head;
    }
    ListNode cur = head;
    while (cur.next != null) {
        if (cur.val == cur.next.val) {
            //删除下一个结点
            cur.next = cur.next.next;
        } else {
            //否则cur向后移动
            cur = cur.next;
        }
    }
    return head;
}

leetcode203 移除链表元素

删除元素要从他的前一个元素操作

public ListNode removeElements(ListNode head, int val) {
    if (head == null) {
        return head;
    }
    ListNode dummy = new ListNode(0, head);
    ListNode cur = dummy;
    while (cur.next != null) {
        if (cur.next.val == val) {
            cur.next = cur.next.next;
        } else {
            cur = cur.next;
        }
    }
    return dummy.next;
}

leetcode82 删除排序中的重复元素二

 public ListNode deleteDuplicates(ListNode head) {
    ListNode dummy = new ListNode(0, head);
    ListNode cur = dummy;
    while (cur.next != null && cur.next.next != null) {
        int val = cur.next.val;
        if (cur.next.next.val == val) {
            while (cur.next != null && cur.next.val == val) {
                cur.next = cur.next.next;
            }
        } else {
            cur = cur.next;
        }
    }
    return dummy.next;
}

leetcode19 删除倒数第n个结点

//方法一：双指针
public ListNode removeNthFromEnd(ListNode head, int n) {
    //双指针，先初始化
    ListNode dummy = new ListNode(0, head);
    ListNode right = dummy;
    while (n-- > 0) {
        right = right.next;
    }
    ListNode left = dummy;
    while (right.next != null) {
        left = left.next;
        right = right.next;
    }
    left.next = left.next.next;
    return dummy.next;
}

//方法二：倒序遍历，正序删除
public ListNode removeNthFromEnd(ListNode head, int n) {
    int len = 0;
    ListNode dummy = new ListNode(0, head);
    ListNode index = dummy;
    while (index.next != null) {
        len++;
        index = index.next;
    }
    ListNode cur = dummy;
    int t = len - n;
    while (t-- > 0) {
        cur = cur.next;
    }
    cur.next = cur.next.next;
    return dummy.next;
}

leetcode160链表相交

给你两个单链表的头节点 headA 和 headB ，
请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    ListNode curA = headA;
    ListNode curB = headB;
    int lenA = 0, lenB = 0;
    while (curA != null) { // 求链表A的长度
        lenA++;
        curA = curA.next;
    }
    while (curB != null) { // 求链表B的长度
        lenB++;
        curB = curB.next;
    }
    curA = headA;
    curB = headB;
    // 让curA为最长链表的头，lenA为其长度
    if (lenB > lenA) {
        //1. swap (lenA, lenB);
        int tmpLen = lenA;
        lenA = lenB;
        lenB = tmpLen;
        //2. swap (curA, curB);
        ListNode tmpNode = curA;
        curA = curB;
        curB = tmpNode;
    }
    // 求长度差
    int gap = lenA - lenB;
    // 让curA和curB在同一起点上（末尾位置对齐）
    while (gap-- > 0) {
        curA = curA.next;
    }
    // 遍历curA 和 curB，遇到相同则直接返回
    while (curA != null) {
        if (curA == curB) {
            return curA;
        }
        curA = curA.next;
        curB = curB.next;
    }
    return null;
}

leetcode141 环形链表

public boolean hasCycle(ListNode head) {
    if (head == null) {
        return false;
    }
    ListNode index1 = head;
    ListNode index2 = head;
    while (index2 != null && index2.next != null) {
        index1 = index1.next;
        index2 = index2.next.next;
        if (index1 == index2) {
            return true;
        }
    }
    return false;
}

leetcode142 环形链表二

思路分析：
x = 起点到入口
y = 入口到相遇点
z = 圈内剩余距离

slow = x+y
fast = x+y+n(y+z)

2(x+y) = x+y+n(y+z)

x = n(y+z)-y

x = (n-1)(y+z)+z

如果n=1则x=z

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode index1 = head, index2 = head;

        while (index2 != null && index2.next != null) {
            index1 = index1.next;
            index2 = index2.next.next;
            if (index2 == index1) {
                //判断入口
                ListNode slow = head;
                ListNode fast = index1;
                while (slow != fast) {
                    slow = slow.next;
                    fast = fast.next;
                }
                return fast;
            }
        }
        return null;
    }
}

leetcode234 回文链表

public boolean isPalindrome(ListNode head) {
    //用栈来模拟翻转链表
    Stack<Integer> stack = new Stack();
    //记录长度
    int len = 0;
    ListNode cur = head;
    while (cur != null) {
        stack.push(cur.val);
        cur = cur.next;
        len++;
    }
    //进行出栈操作
    len = len / 2;
    while (len-- > 0) {
        if (head.val != stack.pop()) {
            return false;
        }
        head = head.next;
    }
    return true;
}

也可以通过双指针进行判断

通过快慢指针找到中间节点，翻转后半部分链表，再依次进行比较

leetcode328 奇偶链表

public ListNode oddEvenList(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode odd = head;
    ListNode even = head.next;
    //这个结点的作用是为了最后将偶数结点挂接到奇数结点之后
    ListNode evenHead = even;
    while (odd.next != null && even.next != null) {
        //维护奇数结点串联
        odd.next = even.next;
        odd = odd.next;
        //维护偶数结点串联
        even.next = odd.next;
        even = even.next;
    }
    odd.next = evenHead;
    return head;
}

leetcode86 分隔链表

思路：重新定义两个链表进行拼接

public ListNode partition(ListNode head, int x) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode smallHead = new ListNode(0);
    ListNode bigHead = new ListNode(0);
    ListNode small = smallHead;
    ListNode big = bigHead;
    ListNode cur = head;
    while (cur != null) {
        if (cur.val < x) {
            smallHead.next = cur;
            smallHead = smallHead.next;
        } else {
            bigHead.next = cur;
            bigHead = bigHead.next;
        }
        cur = cur.next;
    }
    bigHead.next = null;
    smallHead.next = big.next;
    return small.next;
}

leetcode148 排序链表

public ListNode sortList(ListNode head) {
    if (head == null) {
        return null;
    }
    ListNode res = head;
    ArrayList<Integer> list = new ArrayList<>();
    while (res != null) {
        list.add(res.val);
        res = res.next;
    }
    ListNode dummy = new ListNode(0, head);
    Collections.sort(list);
    for (int i = 0; i < list.size(); i++) {
        head.val = list.get(i);
        head = head.next;
    }
    return dummy.next;
}

leetcode146 LRU缓存

package com.sfy.LinkedListPractice;

import java.util.HashMap;
import java.util.Map;

public class LRUCache {
    //函数 get 和 put 必须以 O(1) 的平均时间复杂度运行所以必须用双向链表
    private class Node {
        int key, val;
        Node pre, next;

        Node(int key, int val) {
            this.key = key;
            this.val = val;
        }
    }

    //初始化容量
    private final int capacity;
    Node dummy = new Node(0, 0);
    Map<Integer, Node> keyNode = new HashMap<>();

    public LRUCache(int capacity) {
        this.capacity = capacity;
        dummy.pre = dummy;
        dummy.next = dummy;
    }

    public int get(int key) {
        Node node = getNode(key);
        return node == null ? -1 : node.val;
    }

    public void put(int key, int value) {
        //有就更新，没有就插入
        Node node = getNode(key);
        if (node != null) {
            node.val = value;
            return;
        }
        node = new Node(key, value);//新增
        keyNode.put(key, node);
        pushFront(node);//放在最前面
        if (keyNode.size() > capacity) {
            //容量过大就删除
            Node pre = dummy.pre;
            keyNode.remove(pre.key);
            remove(pre);
        }

    }

    private Node getNode(int key) {
        if (!keyNode.containsKey(key)) {
            return null;
        }
        Node node = keyNode.get(key);
        remove(node);//先删除
        pushFront(node);//再更新
        return node;
    }

    private void pushFront(Node node) {
        node.pre = dummy;
        node.next = dummy.next;
        node.pre.next = node;
        node.next.pre = node;
    }

    private void remove(Node node) {
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }
}

leetcode61 旋转链表

思路一：先变成环再找新的头结点

思路二：1.全翻转 2.翻转前len-k 3.翻转后k个

public ListNode rotateRight(ListNode head, int k) {
    if (head == null || k == 0) {
        return head;
    }
    int len = 1;
    ListNode cur = head;
    while (cur.next != null) {
        len++;
        cur = cur.next;
    }
    // k = 5 - 2 - 1 = 2
    k = len - (k % len) - 1;
    cur.next = head;//变成环形链表
    for (int i = 0; i < k; i++) {
        head = head.next;
    }
    //他的下一个位置就是新的头结点
    ListNode newHead = head.next;
    //将尾节点置空
    head.next = null;
    return newHead;
}

leetcode21 合并两个有序链表

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if (list1 == null) {
            return list2;
        }
        if (list2 == null) {
            return list1;
        }
        ListNode newHead = new ListNode();
        ListNode cur = newHead;
        while (list1 != null && list2 != null) {
            if (list1.val <= list2.val) {
                cur.next = list1;
                list1 = list1.next;
            } else {
                cur.next = list2;
                list2 = list2.next;
            }
            cur = cur.next;
        }
        if (list1 != null) {
            cur.next = list1;
        }
        if (list2 != null) {
            cur.next = list2;
        }
        return newHead.next;
    }

leetcode25 k个一组翻转链表

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
       ListNode dummy = new ListNode(0,head);
       ListNode pre = dummy;
       ListNode end = dummy;
       while(end.next!=null){
        for(int i = 0;i<k&& end !=null;i++){//找到要反转的尾部
            end = end.next;
        }
        if(end == null){
            break;
        }
        ListNode start = pre.next;//找到要翻转的头部节点
        ListNode nextStart = end.next;//找到下一个要反转的头结点，用于连接
        end.next = null;
        pre.next = reverse(start);
        start.next=nextStart;
        pre = start;
        end = pre;
       }
       return dummy.next;
    }

    private ListNode reverse(ListNode head) {
        ListNode pre = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = pre;
            pre = curr;
            curr = next;
        }
        return pre;
    }
}
米兰的小铁匠~
关注
  • 10
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法笔记-链表
qq_44228745的博客
08-04 848
请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表。right先走n步，left开始走，左右指针的间隔为n，同时走到right.next==null，就把left.next位置的节点删除。递归方法这里其实只需要看下第一个就可以，因为其他的进阶的链表反转的题目都跟指针法一样，都是在基础的基础上加上计数。给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
算法笔记|Day3链表基础
m0_57632621的博客
07-20 712
算法笔记|Day3链表基础
算法笔记|Day4链表基础II
m0_57632621的博客
07-22 1149
算法笔记|Day4链表基础II
算法笔记：数组模拟双向链表
GANIT的博客
05-20 97
在O（1）时间内实现增/删/改/查，可以使用数组模拟链表。数组：O（1）查找/修改，但是删/查为O（n）链表：O（1）删/查，但是查找/修改为O（n）数组模拟链表相当于数组+链表。
算法刷题笔记--链表篇
Petrichorzncu的博客
06-25 232
注意要先写cur->next,因为如果先写了cur->next->next，假如此时cur->next==null，cur->next->next会出现空指针报错。因为设计链表中所有的方法都是自己写的，所以有可能出现的问题是，实际问题与所表现出来的问题不一致。例如：插入算法写错了，但是运行报错是在取值算法中体现。在链表第index个节点前面插入一个节点。获取链表第index个节点的数值。删除链表的第index个节点。在链表的最前面插入一个节点。在链表的最后面插入一个节点。
ACM算法笔记(三)链表算法
就随便写写....
05-04 918
一、合并两个有序链表 将两个升序链表合并为一个升序链表后返回，新链表是通过拼接两个链表的节点组成的 思路：分别比较两个链表头部的节点，将较小节点的连接到新链表后 public ListNode mergeTwoList(ListNode l1,ListNode l2) { if(l1 == null) return l2; if(l2 == null) return l1; ListNode resultNode = new...
JS算法笔记——移除链表元素
jiang_jin3323的博客
10-21 513
移除链表元素 思路 链表的定义具有递归的性质，因此链表题目常可以用递归的方法求解。这道题要求删除链表中所有节点值等于特定值的节点，可以用递归实现。 对于给定的链表，首先对除了头节点 head以外的节点进行删除操作，然后判断 head 的节点值是否等于给定的val。如果 head 的节点值等于 val，则head 需要被删除，因此删除操作后的头节点为head.next；如果head 的节点值不等于val，则head 保留，因此删除操作后的头节点还是 head。上述过程是一个递归的过程。 递归的终止条件是hea
算法笔记DAY4
2301_77756456的博客
07-25 153
欢迎补充
算法笔记——循环链表
2301_76159452的博客
09-14 200
算法题中，会有一种题目让我们去判断链表里的是否有循环。这里就需要我们要用快慢指针来进行搜索，直接提供代码工作原理如下图因为fast始终会比slow快一步，所以在循环里始终会相遇，若没有循环，那么fast就会读取到最后nullptr处，然后终止判断即可。
《算法笔记》7.3 链表处理
Zhou9841的博客
12-18 702
7.3 链表处理 7.3.1 链表的概念 线性表是一类很常用的数据结构，分为顺序表和链表。其中顺序表可以简单理解为数组。 按正常方式定义一个数组时，计算机会从内存中取出一块连续的地址来存放给定长度的数组；而链表则是由若干个节点组成（每个节点代表一个元素），且节点在内存中的位置通常是不连续的。除此之外，链表的两个节点之间一般通过一个指针来从一个节点指向下一个节点，因此链表的节点一般由两部分构成，即数据域和指针域： struct Node{ typename data ; //数据域 Node* n
算法笔记，有序链表转为二叉搜索树
03-19
在计算机科学中，有序链表转换为高度平衡的二叉搜索树是一项常见的算法问题。这个问题的目标是利用已排序的链表数据，构建一棵二叉搜索树（BST），使得这棵树在保持二叉搜索树特性的同时，还能尽可能地平衡，即左右...
算法笔记.胡凡
03-23
《算法笔记.胡凡》是一本深入浅出的算法学习资料，主要针对想要提升算法能力的读者，无论你是初学者还是有一定基础的程序员，都能从中受益。这本书通过丰富的实例和清晰的代码，帮助读者理解并掌握各种算法的核心...
算法笔记3_算法笔记_浙大_
09-30
《算法笔记3》是针对浙江大学计算机科学与技术专业学生及准备参加PAT（全国计算机等级考试——编程类）的考生编写的参考资料，主要采用C/C++语言进行讲解。这本书旨在帮助读者提升算法理解与编程能力，为机试和PAT...
算法笔记1_算法笔记PAT_算法笔记_
10-01
《算法笔记1_算法笔记PAT_算法笔记》是一份针对浙江大学计算机科学与技术学院机试以及PAT（Programming Ability Test）考试的学习参考资料，主要以C/C++编程语言为载体，深入讲解了各种算法的设计与实现。...
《算法笔记》pdf版，欢迎下载学习~
10-10
《算法笔记》是一本专注于算法学习的书籍，其PDF版本为学习者提供了便捷的电子阅读体验。这本书特别针对想要提高CSP（计算机软件能力认证）分数的读者，无论是初学者还是有一定基础的学习者，都能从中受益。CSP是...
算法的学习笔记—删除链表中重复的结点（牛客JZ76）
业精于勤，荒于嬉
08-14 1252
本文介绍了一种删除排序链表中重复节点的高效算法。通过递归的方式，算法能够有效地删除所有重复节点，并保留链表中仅出现一次的节点。此方法的实现简单且易于理解，同时在时间和空间复杂度方面表现优异，适用于处理大规模数据链表中的重复节点问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 855
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
【LeetCode每日一题】——623.在二叉树中增加一行
IronmanJay的博客
08-14 1178
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
LeeCode Practice Journal | Day43_DP10
最新发布
Janniam的博客
08-14 291
上题的变体，与nums[i]前每一个连续的元素比较变为前一个元素比较。2、返回值不是dp[i]，是dp数组中的最大值。1、数组元素要初始化为1。
软考程序员数据结构与算法笔记：链表、二叉树、哈夫曼编码解析
"软考程序员听课笔记，包含了从第一章到第十二章的完整内容，主要涉及数据结构与算法、查找与二叉树操作、线索二叉树以及平衡二叉树等重要概念。" 在第一章中，重点讲解了数据结构与算法的基础，特别是单链表的操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值