LeetCode 链表专项 (141 / 21 / 203 / 206 / 83 / 25 / 面试题02.05)

已于 2022-04-30 23:45:55 修改
阅读量752 收藏
点赞数
分类专栏： leetcode算法 文章标签： leetcode 算法 java
于 2022-04-20 16:30:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Amxrjgcs/article/details/124292798
版权

记录一些基本操作

单链表反转

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode next = null;
        ListNode pre = null;
        while(head != null) {
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return pre;
    }
}

双向链表反转

public ListNode reverseList(ListNode head) {
        ListNode next = null;
        ListNode pre = null;
        while(head != null) {
            next = head.next;
            head.next = pre;
            head.last = next;
            pre = head;
            head = next;
        }
        return pre;
    }

用链表设计一个队列和栈

Node

public class Node<T> {
    T val;
    Node next;

    public Node() {
    }

    public Node(T val) {
        this.val = val;
        next = null;
    }

    public Node(T val, Node next) {
        this.val = val;
        this.next = next;
    }
}

Stack

public class LinkedStack<T> {
    Node<T> head = null;
    int size = 0;

    public boolean isEmpty() {
        return size == 0;
    }
    public int size() {
        return size;
    }

    public void push(T val) {
        Node<T> node = new Node<>(val);
        if (head == null) {
            head = node;
        } else {
            node.next = head;
            head = node;
        }
        size++;
    }

    public T pop() {
        T res = null;
        if (head != null) {
            res = head.val;
            head = head.next;
            size--;
        }
        return res;
    }

    public T peek() {
        return head == null ? null : head.val;
    }
}

Queue

public class LinkedQueue<T> {
    Node head = null;
    Node tail = null;
    int size = 0;

    // 队列添加元素
    public void offer(T val) {
        Node<T> node = new Node<>(val);
        if (tail == null) {
            head = node;
            tail = node;
        } else {
            tail.next = node;
            tail = node;
        }
        size++;
    }

    // 队列出队
    public T poll() {
        T res = null;
        if (head != null) {
            res = (T) head.val;
            head = head.next;
            size--;
        }
        if (head == null) {
            tail = null;
        }
        return res;
    }

    // 查看对头元素
    public T peek() {
        if (head != null) {
            return (T) head.val;
        }
        return null;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }
}

用双链表设计一个双端队列

class NodeD<V> {
    public V val;
    public NodeD<V> last;
    public NodeD<V> next;

    public NodeD(V val) {
        this.val = val;
        this.last = null;
        this.next = null;
    }
}

public class LinkedDeque<T> {
    NodeD<T> head;
    NodeD<T> tail;
    int size;

    public LinkedDeque() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }

    public void pushHead(T val) {
        NodeD<T> node = new NodeD<>(val);
        if (head != null) {
            node.next = head;
            head.last = node;
            head = node;
        } else {
            head = node;
            tail = node;
        }
        size++;
    }

    public void pushTail(T val) {
        NodeD<T> node = new NodeD<>(val);
        if (tail != null) {
            tail.next = node;
            node.last = tail;
            tail = node;
        } else {
            head = node;
            tail = node;
        }
        size++;
    }

    public T pollHead() {
        T res = null;
        if (head == null) return res;

        if (head == tail) {
             res = head.val;
             head = null;
             tail = null;
        } else {
            res = head.val;
            head = head.next;
            head.last = null;
        }
        size--;

        return res;
    }

    public T pollTail() {
        T res = null;
        if (tail == null) return res;

        if (head == tail) {
            res = tail.val;
            head = null;
            tail = null;
        } else {
            res = tail.val;
            tail = tail.last;
            tail.next = null;
        }
        size--;
        return res;
    }
}

141. 环形链表

在这里插入图片描述

思路

经典解法就是⽤两个指针，⼀个跑得快，⼀个跑得慢。如果不含有环，跑得快的那个指针最终会遇到 null，说明链表不含环；如果含有环，快指针最终会超慢指针⼀圈，和慢指针相遇，说明链表含有环。

代码实现(java)

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null || head.next == null) return false;

        ListNode fastIndex = head;
        ListNode slowIndex = head;
        while(fastIndex != null && fastIndex.next != null) {
            slowIndex = slowIndex.next;
            fastIndex = fastIndex.next.next;
            if(slowIndex == fastIndex) return true;
        }
        return false;
    }
}

已知链表有环，返回环的起点位置

思路

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码实现(java)

ListNode detectCycle(ListNode head) {
	ListNode fast, slow;
	fast = slow = head;
	while (fast != null && fast.next != null) {
		fast = fast.next.next;
		slow = slow.next;
		if (fast == slow) break;
	}
	
	// 上⾯的代码类似 hasCycle 函数
	slow = head;
	while (slow != fast) {
		fast = fast.next;
		slow = slow.next;
	}
	return slow;
}

找到链表的中点

思路

在这里插入图片描述
在这里插入图片描述

代码实现

while (fast != null && fast.next != null) {
	fast = fast.next.next;
	slow = slow.next;
}
// slow 就在中间位置
return slow;

寻找链表的倒数第 k 个元素

思路

在这里插入图片描述

代码实现

ListNode slow, fast;
slow = fast = head;
while (k-- > 0)
	fast = fast.next;
while (fast != null) {
	slow = slow.next;
	fast = fast.next;
}
return slow;

21. 合并两个有序链表

在这里插入图片描述

思路

  1. 设立一个临时头结点dummy(设置它为不存在的节点)，让其next指向给出的链表，方便操作以及最终的返回(dummy.next)
  2. 在设立一个cur节点，作为链表的操作节点，指向dummy
  3. 循环遍历两个链表，循环条件就设为l1 != null && l2 != null
  4. 进入循环，每次比较 l1和l2两个节点的值的大小，找到较小的那一个进行指针的后移，与链表的链接操作
	if(l1.val < l2.val) {
	    cur.next = l1;
	    cur = l1;
	    l1 = l1.next;
	} else {
	    cur.next = l2;
	    cur = l2;
	    l2 = l2.next;
	}
  1. 一直遍历知道一个链表为空，最后再判断不为空的链表，直接与结果链表相连
  2. 返回dummy.next就是最终的结果

代码实现(java)

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        while(l1 != null && l2 != null) {
            if(l1.val < l2.val) {
                cur.next = l1;
                cur = l1;
                l1 = l1.next;
            } else {
                cur.next = l2;
                cur = l2;
                l2 = l2.next;
            }
        }

        if(l1 == null) {
            cur.next = l2;
        } else {
            cur.next = l1;
        }
        return dummy.next;
    }
}

203. 移除链表元素

在这里插入图片描述

思路

  1. 设立一个临时头结点dummy(设置它为不存在的节点)，让其next指向给出的链表，方便操作以及最终的返回(dummy.next)
  2. 在设立一个cur节点，作为链表的操作节点，指向dummy
  3. 循环遍历给出链表，以cur.next作为遍历的链表元素，判断cur.next.val 是否等于 val，如果等于，就将cur.next = cur.next.next;，相当于将cur.next跳过；否则继续向后遍历cur = cur.next
  4. 最终返回dummy.next

代码实现(java)

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(-1);
        dummy.next = 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;
    }
}

206. 反转链表

在这里插入图片描述

思路

1 -> 2 -> 3 -> 4 -> null
null <- 1 <- 2 <- 3 <- 4

  1. 定义两个节点，prev = null 、cur = head 分别表示前一个节点和当前节点
  2. 遍历链表，每一步将当前节点的 next 指向 prev ，然后将 prev 和 cur 分别后移一位
  3. 以此类推，最后返回 prev 也即反转后链表的头结点

代码实现(java)

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;  // 前节点
        ListNode cur = head;    // 当前节点
        while(cur != null) {
            ListNode next = cur.next;  // 临时节点，指向当前节点的后一个
            cur.next = prev;  // 让当前节点的next指针指向前一个节点
            prev = cur; // 前节点后移到当前节点
            cur = next; // 当前节点移到下一个节点
        }
        return prev;
    }
}

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

在这里插入图片描述

思路

  1. 记录两个指针，pre 是指向前一个节点的指针，next是寻找后一个与 pre 不同的指针
  2. 遍历链表并寻找，当next.val == pre.val，说明是重复的节点，就将pre的next指针指向 next的next，然后next后移；当next.val ！= pre.val，说明不是重复节点，就将pre指向next，然后next后移
  3. 以此类推，最后返回head即可

代码实现(java)

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next == null) return head;

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

25. K个一组反转链表

K个一组反转链表

面试题 02.05. 链表求和

链表求和

永远在摸鱼的桃
关注
专栏目录
LeetCode刷题记录---程序员面试金典(第 6 版)
weixin_43646592的博客
03-25 527
LeetCode刷题记录---程序员面试金典(第 6 版)
Leetcode 数组专项
qq_44978607的博客
02-23 135
https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence/ 674. 最长连续递增序列 classSolution{ publicintfindLengthOfLCIS(int[]nums){ if(nums.length==0||nums.length...
LeetCode 链表专项
weixin_43860460的博客
06-02 116
61. 旋转链表 题目描述
LeetCode 刷题笔记
ZY-JIMMY
01-25 1149
文章目录前言源码地址初级算法 - 题目清单ArrayStringsLinked ListTreesSorting and SearchingDynamic ProgrammingDesignMathOthers 前言 开始刷LeetCode了，包括初级算法、中级算法、高级算法以及一些专项练习，期间会对一些题目或者分类单独写博客总结，源码放在了GitHub里，都包含了算法思想和题目分析，会一直Upd...
Leetcode动态规划专题（共38道）
weixin_45627369的博客
04-10 6166
某一问题有很多重叠子问题 每一状态一定由上一状态推导出来 而贪心没有状态推导，而是直接选局部最优 解决方式： 确定dp数组（dp table）以及下标的含义 确定递推公式 dp数组如何初始化 确定遍历顺序 举例推导dp数组 模拟：举例推导dp数组 检查：打印dp数组 1.Leetcode509. 斐波那契数 class Solution { public: int fib(int n) { //第i个数的值 vector<int>n
合并排序序列
冰美式的博客
03-06 282
21、合并排序序列 merge-sorted-array: Given two sorted integer arrays A and B, merge B into A as one sorted array. Note: You may assume that A has enough space to hold additional elements from B. The number o...
【LeetCode】链表专题
Arthur的博客
06-19 167
LeetCode链表专题
leetcode---链表类型----每日一题---第206题
CSDNwg的博客
03-04 324
leetcode刷题日志
itcharge#LeetCode-Py#面试题 02.05. 链表求和1
07-25
面试题 02.05. 链表求和标签：递归、链表、数学难度：中等题目大意给定两个非空的链表 l1 和 l2，表示两个非负整数，每位数字都是按照逆序的方式存储的，每
程序员面试金典 – 面试题 02.05. 链表求和
12-22
给定两个用链表表示的整数，每个节点包含一个数位。 这些数位是反向存放的，也就是个位排在链表首部。 编写函数对这两个整数求和，并用链表形式返回结果。 示例： 输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295...
JavaScript刷LeetCode拿offer-高频链表题
m0_67615103的博客
12-12 287
首先需要了解链表的概念。
LeetCode-题目详解（六）：链表【链表的中间节点：左半链表的结尾节点】【slow = head | fast = head | while fast and fast.next】
u013250861的博客
05-27 2013
当「乌龟」和「兔子」从链表上的同一个节点开始移动时，如果该链表中没有环，那么「兔子」将一直处于「乌龟」的前方；链表具有天然的递归性，一个链表例如 1->2->3->4->5->NULL ，可以看成头节点(节点值为 1 的节点)后面挂接一个更短的链表(缺少节点值为 1 的节点，以节点值为 2 的节点为头节点) 1->更短的链表，依次类推。这样以来，我们首先使用哈希表进行定位，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头部，即可在 O(1) 的时间内完成 get 或者 put 操作。
【数据结构与算法 | 灵神题单 | 删除链表篇】力扣2487, 237
2301_80912559的博客
09-09 843
每个节点的值都是 1 ，所以没有需要移除的节点。需要移除的节点是 5 ，2 和 3。移除每个右侧有一个更大数值的节点。- 节点 13 在节点 5 右侧。- 节点 13 在节点 2 右侧。- 节点 8 在节点 3 右侧。给你一个链表的头节点。返回修改后链表的头节点。
LeetCode 2181.合并零之间的节点
weixin_50878507的博客
09-09 549
给你一个链表的头节点head，该链表包含由0分隔开的一连串整数。链表的和的节点都满足。对于每两个相邻的0，请你将它们之间的所有节点合并成一个节点，其值是所有已合并节点的值之和。然后将所有0移除，修改后的链表不应该含有任何0。返回修改后链表的头节点head。
【JavaScript】LeetCode：707设计链表
最新发布
weixin_45980065的博客
09-14 466
【代码】【JavaScript】LeetCode：707设计链表。
Leetcode Hot 100刷题记录 -Day16（旋转图像）
weixin_45864705的博客
09-14 169
你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。请你将图像顺时针旋转 90 度。
leetcode-617. 合并二叉树
曼巴的博客
09-11 228
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；1）如果没有root1，return root2。2）如果没有root2，return root1。null 的节点将直接作为新二叉树的节点。合并过程必须从两个树的根节点开始。3）根结点处理：两节点值加和。4）遍历两棵树的左节点。5）遍历两棵树的右节点。返回合并后的二叉树。
408算法题leetcode--第一天
weixin_58073817的博客
09-11 382
【代码】408算法题leetcode--第一天。
【三元组枚举中点】【树状数组】个人练习-Leetcode-1395. Count Number of Teams
Rstln的博客
09-09 374
看了题解还有用树状数组的写法。树状数组建议看这个视频（https://www.bilibili.com/video/BV1ce411u7qP/）了解下，就能明白三个相关函数。【三元组】中，中间的点总是特殊的，可以考虑枚举中点。，为1表示这个下标的数字出现过，为0表示没出现过。然后对这个桶数组求前缀和得到一个数组，这个数组就是。，找出两边的大于和小于中间点的数量，然后【左小✖️右大 + 左大✖️右小】就是答案。但知道树状数组了，该怎么应用到这个题目呢？，这样就可以知道，在某个位置。的数目，也就是潜在的。
Python双指针算法解LeetCode2/3/4Sum问题
"这篇资源主要讨论了如何使用Python的双指针算法来解决LeetCode中的2Sum、3Sum和4Sum问题，提供了不同方法的代码实现，包括暴力解法、排序优化以及哈希表结构的应用。" 在LeetCode中，2Sum、3Sum和4Sum是经典的数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值