LeetCode Week 3 链表

最新推荐文章于 2024-04-20 20:50:41 发布
最新推荐文章于 2024-04-20 20:50:41 发布
阅读量148 收藏
点赞数
分类专栏： LeetCode刷题笔记 文章标签： 链表 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/knight20160302/article/details/120140894
版权

常规题

class Solution {
    public ListNode reverseList(ListNode head) {
         if (head == null) {
            return null;
        }

        ListNode pre = null;
        ListNode cur = head;

        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }

        return pre;
    }
}


class Solution {
   public ListNode reverseBetween(ListNode head, int left, int right) {
         ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;

        ListNode pre = dummyNode;
        for (int i = 0; i < left - 1; i++) {
            pre = pre.next;
        }

        ListNode cur = pre.next;

        for (int i = 0; i < right - left; i++) {
            ListNode next = cur.next;
            cur.next = next.next;
            next.next = pre.next;
            pre.next = next;
        }
        
        return dummyNode.next;
    }  
}

class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode smallHead = new ListNode(-1);
        ListNode small = smallHead;
        ListNode largeHead = new ListNode(-1);
        ListNode large = largeHead;

        while (head!=null) {
            if(head.val < x) {
                small.next = head;
                small = small.next;
            } else {
                large.next = head;
                large = large.next;
            }
            head = head.next;
        }
        
        small.next = largeHead.next;
        large.next = null;
        
        return smallHead.next;
    }
}

class Solution {
    public ListNode oddEvenList(ListNode head) {
       if (head == null) {
            return null;
        }

        ListNode evenHead = head.next;

        ListNode even = evenHead;
        ListNode odd = head;
        while ((even != null && even.next != null)) {
            odd.next = even.next;
            odd = odd.next;
            even.next = odd.next;
            even = even.next;
        }

        odd.next = evenHead;

        return head;
    }
}

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummyHead = new ListNode(-1);
        ListNode cur = dummyHead;
        int carry = 0;

        while (l1 != null && l2 != null) {
            int sum = l1.val + l2.val + carry;
            int nodeVal = sum % 10;
            carry = sum / 10;
            cur.next = new ListNode(nodeVal);
            cur = cur.next;
            l1 = l1.next;
            l2 = l2.next;
        }

        while (l1 != null) {
            int sum = l1.val + carry;
            int nodeVal = sum % 10;
            carry = sum / 10;
            cur.next = new ListNode(nodeVal);
            cur = cur.next;
            l1 = l1.next;
        }

        while (l2 != null) {
            int sum = l2.val + carry;
            int nodeVal = sum % 10;
            carry = sum / 10;
            cur.next = new ListNode(nodeVal);
            cur = cur.next;
            l2 = l2.next;
        }

        if (carry > 0) {
            cur.next = new ListNode(carry);
        }

        return dummyHead.next;
    }
}

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
       Stack<Integer> s1 = new Stack<>();
        Stack<Integer> s2 = new Stack<>();

        while (l1 != null) {
            s1.push(l1.val);
            l1 = l1.next;
        }

        while (l2 != null) {
            s2.push(l2.val);
            l2 = l2.next;
        }

        int carry = 0;
        ListNode tail = null;

        while (!s1.isEmpty() || !s2.isEmpty() || carry != 0) {

            int v1 = s1.isEmpty() ? 0 : s1.pop();
            int v2 = s2.isEmpty() ? 0 : s2.pop();

            int val = v1 + v2 + carry;

            carry = val /10;
            val %= 10;

            ListNode node = new ListNode(val);
            node.next = tail;
            tail = node;
        }

        return tail;
    }
}

class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null) {
            return false;
        }

        if(head.next == null) {
            return true;
        }

        List<Integer> vals = new ArrayList<>();
        ListNode p = head;
        while(p!=null) {
            vals.add(p.val);
            p=p.next;
        }

        int size = vals.size();
        int middle = size / 2;
        for (int i = 0; i <middle ; i++) {
            if(!vals.get(i).equals(vals.get(size - 1 - i))) {
                return false;
            }
        }

        return true;
    }
}

删除节点


class Solution {
    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.next;
            }
        }

        return head;
    }
}

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;

        ListNode cur = dummyNode;
        while(cur.next !=null) {
            if(cur.next.val == val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }

        return dummyNode.next;
    }
}


class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) {
            return null;
        }

        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;
        ListNode cur = dummyNode;
        while (cur.next != null && cur.next.next != null) {
            if (cur.next.val == cur.next.next.val) {
                int x = cur.next.val;
                while (cur.next != null && cur.next.val == x) {
                    cur.next = cur.next.next;
                }
            } else {
                cur = cur.next;
            }
        }
        return dummyNode.next;
    }
}

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

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
       if (head == null) {
            return null;
        }

        int len = 0;
        ListNode p = head;
        while (p != null) {
            len++;
            p = p.next;
        }

        int index = len - n;
        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;
        int i = 0;
        ListNode pre = dummyHead;
        ListNode cur = head;
        while (i < index) {
            pre = cur;
            cur = cur.next;
            i++;
        }
        pre.next = cur.next;
        
        return dummyHead.next;
    }
}

交换旋转


class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;

        ListNode temp = dummyNode;
        while(temp.next != null && temp.next.next!=null) {
            ListNode node1 = temp.next;
            ListNode node2 = temp.next.next;
            temp.next = node2;
            node1.next = node2.next;
            node2.next = node1;

            temp = node1;
        }

        return dummyNode.next;
    }
}

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode hair = new ListNode(0);
        hair.next = head;
        ListNode pre = hair;

        while (head != null) {
            ListNode tail = pre;
            // 查看剩余部分长度是否大于等于 k
            for (int i = 0; i < k; ++i) {
                tail = tail.next;
                if (tail == null) {
                    return hair.next;
                }
            }
            ListNode nex = tail.next;
            ListNode[] reverse = myReverse(head, tail);
            head = reverse[0];
            tail = reverse[1];
            // 把子链表重新接回原链表
            pre.next = head;
            tail.next = nex;
            pre = tail;
            head = tail.next;
        }

        return hair.next;
    }

    public ListNode[] myReverse(ListNode head, ListNode tail) {
        ListNode prev = tail.next;
        ListNode p = head;
        while (prev != tail) {
            ListNode nex = p.next;
            p.next = prev;
            prev = p;
            p = nex;
        }
        return new ListNode[]{tail, head};
    }
}

61. 旋转链表

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if(head == null || k == 0) {
            return head;
        }

        ListNode cur = head;
        int len = 0;
        while(cur !=null ) {
            len++;
            cur = cur.next;
        }

        int rightLen = k % len;
        if(rightLen == 0) {
            return head;
        }
        int leftLen = len - rightLen;
        cur = head;
        for (int i = 0; i < leftLen - 1; i++) {
            cur = cur.next;
        }

        ListNode newHead = cur.next;
        ListNode p = newHead;
        cur.next = null;
        for (int i = 0; i < rightLen - 1; i++) {
            p = p.next;
        }

        p.next = head;

        return newHead;
    }
}

链表排序


class Solution {
    public ListNode insertionSortList(ListNode head) {
        if (head == null) {
            return head;
        }
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode lastSorted = head, curr = head.next;
        while (curr != null) {
            if (lastSorted.val <= curr.val) {
                lastSorted = lastSorted.next;
            } else {
                ListNode prev = dummyHead;
                while (prev.next.val <= curr.val) {
                    prev = prev.next;
                }
                lastSorted.next = curr.next;
                curr.next = prev.next;
                prev.next = curr;
            }
            curr = lastSorted.next;
        }
        return dummyHead.next;
    }
}

class Solution {
    public ListNode sortList(ListNode head) {
        return sortList(head, null);
    }

    public ListNode sortList(ListNode head, ListNode tail) {
        if (head == null) {
            return head;
        }
        if (head.next == tail) {
            head.next = null;
            return head;
        }
        ListNode slow = head, fast = head;
        while (fast != tail) {
            slow = slow.next;
            fast = fast.next;
            if (fast != tail) {
                fast = fast.next;
            }
        }
        ListNode mid = slow;
        ListNode list1 = sortList(head, mid);
        ListNode list2 = sortList(mid, tail);
        ListNode sorted = merge(list1, list2);
        return sorted;
    }

    public ListNode merge(ListNode head1, ListNode head2) {
        ListNode dummyHead = new ListNode(0);
        ListNode temp = dummyHead, temp1 = head1, temp2 = head2;
        while (temp1 != null && temp2 != null) {
            if (temp1.val <= temp2.val) {
                temp.next = temp1;
                temp1 = temp1.next;
            } else {
                temp.next = temp2;
                temp2 = temp2.next;
            }
            temp = temp.next;
        }
        if (temp1 != null) {
            temp.next = temp1;
        } else if (temp2 != null) {
            temp.next = temp2;
        }
        return dummyHead.next;
    }
}

lass Solution {
    public void reorderList(ListNode head) {
        if (head == null) {
            return;
        }
        List<ListNode> list = new ArrayList<ListNode>();
        ListNode node = head;
        while (node != null) {
            list.add(node);
            node = node.next;
        }
        int i = 0, j = list.size() - 1;
        while (i < j) {
            list.get(i).next = list.get(j);
            i++;
            if (i == j) {
                break;
            }
            list.get(j).next = list.get(i);
            j--;
        }
        list.get(i).next = null;
    }
}
Invincible_008
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java加密算法pbkdf2
sun134911的博客
03-08 2346
PBKDF2算法通过多次hash来对密码进行加密。原理是通过password和salt进行hash，然后将结果作为salt在与password进行hash，多次重复此过程，生成最终的密文。此过程可能达到上千次，逆向破解的难度太大，所以PBKDF2算法是安全的。 package com.bolt.zkkw.util; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.PBEKeySpec; import java.math..
LeetCode 141 环形链表讲解 PPT
03-12
LeetCode 141 环形链表讲解 PPT提供了检测链表中是否存在环形结构的一种解决方案。该PPT通过样例和代码，展示了检测链表中是否存在环形结构的过程。 样例一： 输入：head = [3,2,0,-4] 输出：true 哈希表：3,2,0,-...
链表：LeetCode141.环形链表
清风微浪又何妨的博客
12-01 238
LeetCode链表系列题解
PBKDF2算法原理
HORHEART的博客
08-28 1万+
PBKDF2算法原理算法介绍函数定义PBKDF2的算法流程主密钥生成流程图算法执行步骤结合SHA-256算法流程图PBKDF2算法的产生背景参考资料 算法介绍 PBKDF2(Password-Based Key Derivation Function) 应用一个伪随机函数以导出密钥。导出密钥的长度本质上是没有限制的（但是，导出密钥的最大有效搜索空间受限于基本伪随机函数的结构）。 它的基本原理是通过一个伪随机函数（例如 HMAC 函数），把明文和一个盐值作为输入参数，然后重复进行运算，并最终产生密钥。 如果重
【LeetCode】C++ ：中等题 - 链表 19. 删除链表的倒数第 N 个结点
weixin_44566432的博客
01-26 212
中等题训练开始啦！！！紧张 19. 删除链表的倒数第 N 个结点 难度中等1188 给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。 进阶：你能尝试使用一趟扫描实现吗？ 示例 1： 输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2： 输入：head = [1], n = 1 输出：[] 示例 3： 输入：head = [1,2], n = 1 输出：[1] 提示： 链表中结点的数目为sz ...
深入了解PBKDF2：密码学中的关键推导函数
04-20 1013
定义：PBKDF2（Password-Based Key Derivation Function 2）是一种基于密码的密钥派生函数，旨在从密码和盐值派生出加密密钥。PBKDF2使用可配置的伪随机函数（通常是HMAC）来执行多轮迭代，从而增加生成密钥的难度。特点灵活性：PBKDF2支持不同的哈希函数和迭代次数，可以根据需要进行配置。安全性：通过多轮迭代和盐值，PBKDF2增加了生成密钥的计算复杂度，提高了密码的安全性。标准化。
php-leetcode题解之链表的中间结点.zip
最新发布
06-10
在IT领域，尤其是在编程竞赛和面试中，LeetCode是一个非常受欢迎的在线平台，它提供了大量的算法问题供程序员解决。本话题聚焦于一个特定的题目——找到链表的中间节点，这是链表数据结构中常见的问题，对于理解和...
leetcode：移除链表元素 python解法
12-21
在LeetCode上，有一道经典的链表操作问题——移除链表元素。这个问题要求我们从给定的单链表中删除所有值等于`val`的节点。本文将深入解析问题的解决方案，并提供一种使用Python实现的方法。 ### 1. 题目说明 题目...
Leetcode 反转链表.js
02-21
LeetCode 206的题目是“反转链表”（Reverse Linked List），它要求将一个单链表的所有节点反转，并返回反转后链表的头节点。这是一个基础但非常重要的链表操作问题，它不仅考察了对链表数据结构的理解，还涉及到了...
leetcode-链表笔记
02-06
3. **LeetCode 中的链表题目** - **2. Add Two Numbers**：给定两个非空链表表示两个非负整数，相加后返回结果链表。 - **141. Linked List Cycle**：判断链表是否有环，如有，找到环的入口节点。 - **19. Remove...
ListNode list=new ListNode() 、 ListNode list=new ListNode(0) 与 ListNode list=null 的区别
热门推荐
看风起云落的博客
08-17 2万+
ListNode list=new ListNode()初始化一个空节点，无值,不提倡此种写法。 ListNode list=new ListNode(0) 初始化一个节点值为0的空节点，最常用最正规写法 ListNode list=null 为空，什么都没有，一般不这么写； ...
链表排序
星辰大海
02-02 865
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *g
leetcode练题:剑指offer
xuruhua的博客
08-23 89
一、输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public int[] reversePrint(ListNode head) {
leetcode错题记录（4）
weixin_50813307的博客
09-05 145
leecode个人刷题记录
LeetCode算法之--链表系列
程序大视界
12-21 728
LeetCode链表常见算法题型
PBKDF2实现
Tanyboye的博客
03-18 8903
PBKDF2简介常见的加密算法，如MD5，此类算法为单向的，无法通过逆向破解，但由于技术的不断进步，可以通过字典和暴力破解。后来人们通过加盐来增加密码的安全性，但彩虹表的出现让这种方式也变得不安全。以至于出现了现在的PBKDF2算法。PBKDF2算法通过多次hash来对密码进行加密。原理是通过password和salt进行hash，然后将结果作为salt在与password进行hash，多次重复此...
算法练习--移除重复节点__HashSet
QilanAllen的博客
06-02 245
题目 编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。 示例 输入：[1, 2, 3, 3, 2, 1] 输出：[1, 2, 3] 个人思路 定义一个HashSet来存储值，通过它判断是否有重复节点。因为要涉及到节点的删除操作，那么我们需要知道节点的前驱，所以还要定义一个前驱节点，遍历链表，判断当前节点的值是否已经存在于set中，如果没有，表示不重复，链表向下遍历；否则，代表存在重复，需要删除当前节点。 代码 /** * Definition for singly-linke
集合-List, HashSet与HashMap
Daniel_C_C的博客
09-18 355
一 概述 Java的集合类主要由Map类和Collection类接口派生而来，其中Collection接口有两个常用的子接口，即List和Set，所以通常说Java集合框架由三大类接口构成（Map接口、List接口、Set接口）。 Collection接口可以存储一组不唯一、无序的对象。List接口存储一组有序不唯一的对象，Map存储一组无序唯一的对象。Map存储一组键值对象，提供key到value的映射 二 ArrayList 三 LinkedList 四 HashSet 五...
链表：自引用结构
zhoufy的博客
02-13 1064
链表： 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作。 例： #include typedef struct student {
Python实现LeetCode合并排序链表经典题解
"在LeetCode中，'合并两个排序数组链表'是一道经典的面试题目，主要考察对递归和链表操作的理解。这里有四种不同的Python实现方式来解决这个问题，它们都属于List Node数据结构的范畴。 首先，第一种方案是通过递归...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值