算法与数据结构新手班第4节

最新推荐文章于 2025-12-11 12:03:51 发布
原创 最新推荐文章于 2025-12-11 12:03:51 发布 · 118 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #算法 #java

本文主要探讨了单链表和双链表的概念，并通过一系列题目讲解了如何进行链表反转、使用链表实现队列和栈，以及双端队列的构建。此外，还涉及到了K个节点的组内逆序调整和链表中的数学运算问题，如两数相加和有序链表合并。

单链表与双链表

单链表：两个属性分别为值，和下一个节点的地址

双链表：三个属性分别为值，上一个节点的地址和下一个节点的地址

题目一：单链表的反转

public class reverseLinkedList {
    public static class Node {
        public int vaule;
        public Node next;

        public Node(int vaule) {
            this.vaule = vaule;
        }

    }
    static Node reverseLinkedList(Node head) {
        Node pre = null;
        Node next = null;
        while (head != null) {
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return pre;
    }
    public static void main(String[] args) {
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        //如果仅像下面这样操作，head的vaule还是1,因为引用的传递,在上面的reverseLinkedList方法中如果在head = next;后面对head的属性进行操作,改变的实际是next的属性,因为head指向next
        //reverseLinkedList(head);
        //System.out.println(head.vaule);//head.vaule=1
        head = reverseLinkedList(head);
        System.out.println(head.vaule);
        System.out.println(head.next.vaule);
        System.out.println(head.next.next.vaule);
    }
}

JVM的释放：在上面这种链表中，只有一个对象head，如果先改变了head的指向，而不改变head，原先head的所有指向都会消失，这叫做JVM的释放

题目二：双链表的反转

public class reverseDoubleList {
    public static class Node {
        public int vaule;
        public Node next;
        public Node last;

        public Node(int vaule) {
            this.vaule = vaule;
        }
    }

    static Node reverseDoubleList(Node head) {
        Node pre = null;
        Node next = null;
        while (head != null) {
            //记录下一个位置
            next = head.next;
            //改变head的last
            head.last = next;
            //改变head的next
            head.next = pre;
            //改变pre位置
            pre = head;
            //改变head位置
            head = next;

        }
        return pre;
    }

    public static void main(String[] args) {
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.last = head;
        head.next.next = new Node(3);
        head.next.next.last = head.next;
        head = reverseDoubleList(head);
        System.out.println(head.vaule);
        System.out.println(head.next.vaule);
        System.out.println(head.next.next.vaule);
    }
}

题目三：用单链表实现队列

接收一些数据（为队列）,然后按接收的顺序输出

public class LinkedListToQueue {
    public static class Node<E> {
        E vaule;
        Node next;


        public Node(E vaule) {
            this.vaule = vaule;

        }

    }
    static class MyQueue<V>{
        Node<V> head;
        private Node<V> tail;

        public MyQueue() {
        }

        public void get(V v){
            Node<V> node = new Node<>(v);
            if(head != null){
                tail.next = node;
            }else{
                head = node;
            }
            tail = node;
        }
        public V peek(){
            V ans = head.vaule;
            head = head.next;
            //防止产生脏数据
            if(head == null){
                tail = null;
            }
            return ans;
        }
    }

    public static void main(String[] args) {
        MyQueue<Integer> mq = new MyQueue<>();
        mq.get(1);
        mq.get(2);
        mq.get(3);
        System.out.println(mq.peek());
        System.out.println(mq.peek());
        System.out.println(mq.peek());
    }
}

脏数据：从目标中取出的数据已经过期、错误或者没有意义，这种数据就叫做脏数据。

题目三：用单链表实现栈

接收一些数据（为栈）,然后按接收的倒序输出

public class LinkedListToStack {
    static class Node<E> {
        E vaule;
        Node next;

        Node() {
        }

        Node(E vaule) {
            this.vaule = vaule;
        }

        static class MyStack<V> {
            Node<V> head;

            MyStack() {
            }

            void put(V v) {
                Node<V> node = new Node<>(v);
                node.next = head;
                head = node;
            }

            V peek() {
                V ans = head.vaule;
                head = head.next;
                return ans;
            }
        }
    }

    public static void main(String[] args) {
        //引用类型的传递（当被指向的对象改变时（属性改变不算），指向对象会代替原位置）
        Node<Integer> node = new Node<>(1);
        Node<Integer> node2 = new Node<>(2);
        Node<Integer> node3 = new Node<>(3);
        node = node2;
        System.out.println(node.vaule);//2
        node2.vaule = 1;
        System.out.println(node.vaule);//1
        System.out.println(node == node2);//true
        node2 = node3;
        System.out.println(node == node2);//false

        Node.MyStack<String> ms = new Node.MyStack<>();
        ms.put("我是");
        ms.put("中国人");
        System.out.println(ms.peek());
        System.out.println(ms.peek());
    }
}

题目四：用双链表结构实现双端队列

可以在队列两端加元素，读取元素

public class DoubleLinkedListToDeque {
    class Node<V> {
        public V vaule;
        public Node<V> last;
        public Node<V> next;

        public Node(V v) {
            vaule = v;
            last = null;
            next = null;
        }
    }

    class MyDeque<V> {
        private Node<V> head;
        private Node<V> tail;

        public MyDeque() {
        }


        void pushHead(V v) {
            Node<V> node = new Node<>(v);
            if (head == null) {
                tail = node;
            } else {
                head.last = node;
                node.next = head;
            }
            head = node;
        }

        void pushTail(V v) {
            Node<V> node = new Node<>(v);
            if (tail == null) {
                head = node;
            } else {
                tail.next = node;
                node.last = tail;
            }
            tail = node;
        }

        V pollHead() {
            V ans = null;
            if (head != null) {
                ans = head.vaule;
                head = head.next;
                if (head != null) {
                    head.last = null;
                } else {
                    tail = null;
                }
            }
            return ans;
        }

        V pollTail() {
            V ans = null;
            if (tail != null) {
                ans = tail.vaule;
                tail = tail.last;
                if (tail != null) {
                    tail.next = null;
                } else {
                    head = null;
                }
            }
            return ans;
        }
    }
}

双链表不会自动释放

题目五：K个节点的组内逆序调整(Hard)

给定一个单链表的头节点head，和一个正数k

实现每k个数的内部逆序，如果最后一组不够k个就不调整

测试链接

    public static ListNode reverseKGroup(ListNode head, int k) {
        ListNode start = head;
        ListNode end = getKGroupEnd(start, k);
        if (end == null) {
            return head;
        }
        // 第一组凑齐了！
        head = end;
        reverse(start, end);
        // 上一组的结尾节点
        ListNode lastEnd = start;
        while (lastEnd.next != null) {
            start = lastEnd.next;
            end = getKGroupEnd(start, k);
            if (end == null) {
                return head;
            }
            reverse(start, end);
            lastEnd.next = end;
            lastEnd = start;
        }
        return head;
    }

    public static ListNode getKGroupEnd(ListNode start, int k) {
        while (--k != 0 && start != null) {
            start = start.next;
        }
        return start;
    }

    public static void reverse(ListNode start, ListNode end) {
        end = end.next;
        ListNode pre = null;
        ListNode cur = start;
        ListNode next = null;
        while (cur != end) {
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        start.next = end;
    }

单链表，因为JVM释放，所以方法的返回值一定不能是void

题目六:链表中的两数相加

测试链接

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 static int getlength(ListNode node) {
        int size = 0;
        while (node != null) {
            size++;
            node = node.next;
        }
        return size;
    }

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

    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int len1 = getlength(l1);
        int len2 = getlength(l2);
        l1 = reverse(l1);
        l2 = reverse(l2);
        ListNode l = len1 > len2 ? l1 : l2;
        ListNode s = len1 > len2 ? l2 : l1;
        int carry = 0;
        int num = l.val + s.val + carry;
        l.val = num % 10;
        ListNode ans = l;
        ListNode last = null;
        carry = num / 10;
        s = s.next;
        last = l;
        l = l.next;
        while (s != null) {
            num = l.val + s.val + carry;
            l.val = num % 10;
            carry = num / 10;
            s = s.next;
            last = l;
            l = l.next;

        }
        while (l != null) {
            num = l.val + carry;
            l.val = num % 10;
            carry = num / 10;
            last = l;
            l = l.next;
        }
        if (carry != 0) {
            last.next = new ListNode(1);
        }
        return reverse(ans);
    }
}

题目七： 合并两个有序链表

测试链接

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 list1, ListNode list2) {
        if (list1 == null || list2 == null) {
            return list1 == null ? list2 : list1;
        }
        ListNode cur = list1.val > list2.val ? list2 : list1;
        ListNode ans = cur;
        ListNode head2 = cur == list1 ? list2 : list1;
        ListNode head = cur.next;
        while (head != null && head2 != null) {
            if (head.val > head2.val) {
                cur.next = head2;
                head2 = head2.next;
            } else {
                cur.next = head;
                head = head.next;
            }
            cur = cur.next;
        }
        cur.next = head == null ? head2 : head;
        return ans;
    }
}

数据结构与算法——从零开始学习（一）基础概念篇
csdn_aiyang的博客
12-06 25万+
前言 数据结构：是指相互之间存在一种或多种特定关系的数据元素的集合用计算机存储、组织数据的方式。数据结构分别为逻辑结构、（存储）物理结构和数据的运算三个部分。 为什么要学数据结构？ 首先，因为数据结构作为计算机专业的专业基础课程，是计算机考研的必考科目之一，如果打算报考计算机专业的研究生，你必须学好它；其次，数据结构是计算机软考、计算机等级考试等相关考试的必考内容之一，想要顺利通过这些考...
数据结构与算法（C++版）学习笔记
YouZhan0的博客
08-10 2091
先学后练2.先学经典，再去拓展延伸3. C/C++数据结构数组、链表、串、栈、队列…经典算法冒泡算法、BF算法…
L1距离和L2距离Matlab代码实现
斯人若彩虹，遇上方知有！
11-14 6187
1、L1距离（也就是曼哈顿距离Manhattan Distance） 这个相对简单点，简要的说就是求点的绝对值 例如下图所示：就是对应位置元素相减然后取绝对值操作！ L1距离计算公式如下： 简单的python代码实现 import numpy as np for i in range(num_test): a = X_test[i]-X_train[j] b ...
350. 两个数组的交集 II
weixin_40290389的博客
11-15 181
给定两个数组，编写一个函数来计算它们的交集。 示例 1： 输入：nums1 = [1,2,2,1], nums2 = [2,2] 输出：[2,2] 示例 2: 输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出：[4,9] 说明： 输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。 我们可以不考虑输出结果的顺序。 进阶： 如果给定的数组已经排好序呢？你将如何优化你的算法？ 如果 nums1 的大小比 nums2 小很多，哪种方法更优？ 如果 nums.
python面试的100题（14）
weixin_30802273的博客
03-21 802
32.请写出一个函数满足以下条件 该函数的输入是一个仅包含数字的list,输出一个新的list，其中每一个元素要满足以下条件： 1、该元素是偶数 2、该元素在原list中是在偶数的位置(index是偶数) def num_list(num): return [i for i in num if i %2 ==0 and num.index(i)%2==0] num = ...
【超全汇总】学习数据结构与算法，计算机基础知识，看这篇就够了
热门推荐
帅地
01-18 10万+
由于文章有点多，并且发的文章也不是一个系列一个系列发的，不过我的文章大部分都是围绕着 数据结构 + 算法 + 计算机网络 + 操作系统 + Linux + 数据库 这几个方面发的，为了方便大家阅读，我整理了一波。不过公众号可以说是不支持修改文章，因为我决定每两三个月就整理一次，会非常详细着按照类别整理出来哦，并且也给出了目录哦。大家记得多看看哦，好多文章都是面试中常问滴 文章目录一、经验/经历/所...
《算法和数据结构》题海战术篇
英雄哪里出来
09-12 5万+
刷了 3333 题 算法题 后的一点点经验总结 —— 题不是这么刷的！
学算法先学数据结构？是否是无稽之谈？
英雄哪里出来
03-02 3万+
头发没了
「算法与数据结构」从入门到进阶吐血整理推荐书单
墨鱼菜鸡
09-09 1654
一.入门系列 这些书籍通过图片、打比方等通俗易懂的方法来讲述，让你能达到懂一些基础算法，线性表，堆栈，队列，树，图，DP算法，背包问题等，不要求会实现，但是看过以下这些书对于之后实现算法打下坚实的思维基础。 很适合在闲暇之余拿出来阅读一番。 1.1 《啊哈！算法》 阅读链接：https://book.douban.com/s...
数据结构在算法中的实际应用案例
AI 算法实战派
06-05 1286
你是否遇到过这样的困惑：学了一堆数据结构（栈、链表、树…），但做题或写代码时总不知道该用哪个？其实，数据结构就像厨房的工具——切菜用菜刀，打鸡蛋用打蛋器，炖肉用砂锅。本文通过6个真实算法场景，帮你建立“问题→数据结构→算法”的思维链路，掌握“如何根据问题选工具”的核心能力。本文从生活故事引入，先通俗解释核心数据结构，再用6个经典案例（括号匹配、两数之和、二叉树遍历、最短路径、任务调度、LRU缓存）展示数据结构如何优化算法。最后总结“选结构”的黄金法则，帮你举一反三。栈：后进先出（括号匹配、函数调用栈）。
数据结构与算法Python语言描述.pptx
06-14
1. 数据结构与算法基础: 数据结构是计算机存储、组织数据的方式，而算法是解决特定问题的一系列步骤。Python语言描述意味着采用Python语言来表达数据结构与算法的设计和实现。 2. 线性结构概念: 线性结构是最基本的...
数据结构算法与应用c++语言描述 pdf +源代码,数据结构算法与应用-c++语言描述（清晰版）.pdf...
weixin_36274181的博客
05-19 2203
数据结构算法与应用-c语言描述(清晰版)下载第一部分 预 备 知 识第1章 C + +程序设计大家好！现在我们将要开始一个穿越“数据结构、算法和程序”这个抽象世界的特殊旅程，以解决现实生活中的许多难题。在程序开发过程中通常需要做到如下两点：一是高效地描述数据；二是设计一个好的算法，该算法最终可用程序来实现。要想高效地描述数据，必须具备数据结构领域的专门知识；而要想设计一个好的算法，则...
redis基础（数据结构）
最新发布
weixin_74390886的博客
12-11 447
zrangebyscore key min max:按照score排序后，获取指定score范围内的元素。hsetnx:添加一个hash类型的key的field值，前提是这个field不存在，否则不执行。hset key field value:添加或者修改hash类型key的field的值。hgetall:获取一个hash类型的key中的所有的field和value。hget key field:获取一个hash类型key的field值。
数据结构之排序
CQ_YM的博客
12-08 758
摘要 本文系统介绍了9种经典排序算法，重点分析了排序稳定性的重要性及其对业务逻辑的影响。通过对比表格清晰展示了各算法的时空复杂度、稳定性和适用场景，包括冒泡排序、插入排序、选择排序等基础算法，以及快速排序、归并排序、堆排序等高效算法。针对不同业务需求（如小数据量、内存限制、稳定性要求等）提供了具体选型建议，并给出了可直接运行的C语言实现代码，涵盖递归/非递归版本。特别强调了快排的优化技巧和归并排序在稳定性场景中的优势，为开发者提供了全面的排序算法实践指南。
数据结构 —— 并查集
zz072320的博客
12-08 663
并查集是一种高效处理动态连通性问题的数据结构，主要用于元素分组和连通性判断。其核心操作包括查找(Find)元素所属集合的根节点，以及合并(Union)两个集合。通过路径压缩和加权标记优化，可显著提升性能。路径压缩使查找路径上的节点直接指向根节点，加权标记则在合并时保持树结构平衡。典型应用包括判断图的连通性和Kruskal最小生成树算法。并查集通过初始化(Init)、查找(Find)和合并(Join)三个基本操作，实现了高效的动态集合管理。
LeetCode 211：设计添加与搜索单词的数据结构（Trie + DFS）
六六哥的博客
12-06 1113
leetcodeWordDictionary()：初始化对象。void addWord(word)：把 word 加入数据结构。bool search(word)：如果存在任意已添加的字符串能和 word 匹配，则返回 true，否则返回 false；word 可能包含 ‘.’，代表任意字母。约束：单词长度不超过 25，search 中的 word 最多包含 2 个 ‘.’，总调用次数最多 10^4。这些约束保证了基于 Trie + DFS 的解法可以轻松通过。char key);
【数据结构】2树
Winkyyyyyy的博客
12-06 971
数据结构第五章
【Zookeeper】数据结构、集群原理、选举机制
xueping_wu的博客
12-08 830
脑裂是在分布式系统中经常出现的问题之一，它指的是由于网络或节点故障等原因，导致一个分布式系统被分为多个独立的子系统，每个子系统独立运行，无法相互通信，同时认为自己是整个系统的主节点，这就会导致整个系统失去一致性和可用性。可以通过设置合适的选举超时时间、设置合适的节点数量等方式来减少脑裂的可能性。同时，可以使用ZooKeeper提供的Watch机制来监听节点状态的变化，及时发现并处理异常情况，从而避免脑裂的发生。Zookeeper集群中的脑裂出现的原因通常有以下2种情况：网络分区。
23、数据结构：树与二叉树的概念、特性及递归实现
weixin_46607526的博客
12-05 709
本文系统介绍了树与二叉树的基本概念、特性及递归实现方法。主要内容包括：1）树的基础术语如度、深度、存储结构；2）二叉树的特殊形式（斜树、满二叉树、完全二叉树）及其数学特性；3）通过前序字符串递归构建二叉树的代码实现；4）前序、中序、后序三种深度优先遍历算法；5）递归销毁树避免内存泄漏的方法。文章通过清晰的代码示例和运行结果，展示了二叉树从创建到遍历再到销毁的完整生命周期，为理解树形数据结构提供了实践指导。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值