数据结构速学笔记：单链表面试题整理总结

最新推荐文章于 2024-07-20 17:53:51 发布
最新推荐文章于 2024-07-20 17:53:51 发布
阅读量253 收藏
点赞数
分类专栏： 数据结构 文章标签： 单链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34501274/article/details/106630381
版权

目录

  1. 单链表倒数第k个节点
  2. 单链表反转链表
  3. 单链表反向打印节点

单链表倒数第k个节点


    /**
     * 单链表倒数第k个节点
     * 思路：1. 遍历链表计算出，有效节点size（头节点排除在外）
     *      2. 倒数K节点对应的节点： size-k
     *      解释：例如链表：head(头节点) -> A.next -> B.next ->C.next -> D.next
     *           head不是有效节点，所以head要排除在外
     *           上述链表有效节点是4个，取倒数第2节点，即C节点，是我们需要的。
     *           size-k=2  从第一个有效节点，往后位移2位，即：从当前A节点，位移2位，是C节点。 即倒数k节点数据
     * */

    public void getK_Node(int k){

        int size=getSize();

        if (k<=0 || k>size){
            return;
        }
        Node curNode = headNode.next;
        for (int i=0;i<size-k;i++){
            curNode=curNode.next;
        }
        log("倒数K节点数据  "+curNode);
    }

    public int getSize(){
        int size=0;
        Node curNode = headNode.next;
        while (curNode != null) {
            size++;
            curNode = curNode.next;
        }
        return size;
    }

单链表反转链表

代码实现


    /**
     * 单链表反转
     */
    public void reverse() {
        // 分析1-->
        if (headNode == null || headNode.next == null || headNode.next.next == null) {
            // 空链表、链表只有一个元素 不用反转
            return;
        }
        Node temp = headNode;
        Node reverseHead = new Node(0, "");
        Node curNode = temp.next; // 当前链表
        Node nextNode; // 临时存储当前链表的下一个链表元素
        while (curNode != null) {
            // 先保存当前链表位置的下一个元素
            nextNode = curNode.next;
            // 分析 2-->
            /** 原链表：temp -> A.next -> B.next -> C.next ->D.next
             * 核心思路：遍历原链表时，每遍历一个元素
             *     1. next指针向后位移1位
             *     2. 同时把链表当前位置的元素给插入到 头节点是reverseHead的链表中，插在reverseHead最前端
             *         2.1 把拿到的元素的next指向原本reverseHead.next指向的数据
             *         2.2 然后把拿到当前的元素，都要插在新链表最前端：即：reverseHead.next指向的位置（头节点后的第一个节点）
             *         解释：  例如当前是 reverseHead.next -> A.next
             *                继续遍历拿到B时: 让B.next ->A.next
             *                               在让reverseHead.next ->B.next
             *                               这样形成 reverseHead.next ->B.next -> A.next
             * */
            curNode.next = reverseHead.next;
            reverseHead.next = curNode;
            // 分析3 --> 把原链表中下一个节点元素，赋值给当前curNode。（就是链表向后位移一位）
            curNode = nextNode;
        }
        //分析4 --> 原链表的头节点指向新链表头节点后的第一个元素（原表头节点替换掉新表头节点）
        // 解释 --> 新表头节点，于后面的节点断开，让原表头节点指向
        temp.next = reverseHead.next;

        // 最终完成单链表的反转
        try {
            showNode();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

图文解释：

在这里插入图片描述

单链表反向打印节点

  /**
     * 单链表，反向打印节点
     * 遍历链表，逐个压入栈中（栈的数据结构先进后），在遍历栈，打印出来。结果符合反向打印链表
     */
    public void reversePrint() {

        Stack<Node> stack = new Stack<>();
        Node curNode = headNode.next;
        while (curNode != null) {
            stack.push(curNode);
            curNode = curNode.next;
        }

        while (stack.size() > 0) {
            System.out.println("反向打印链表节点： " + stack.pop());
        }

    }

完整代码


/**
 * 带头节点的单链表
 */
public class LinkList {
    Node headNode = new Node(0, "");

    /**
     * 不考虑客观条件，直接插在链尾
     */
    public void addNode(Node addNode) {
        Node temp = headNode;
        while (true) {
            if (temp.next == null) { //找到最后一个节点
                break;
            }
            temp = temp.next;
        }
        temp.next = addNode;
    }

    /**
     * 按照顺序节点插入  例：1 、2 、3、4、5
     */
    public void addNodeByOrder(Node addNode) {
        Node temp = headNode;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.num > addNode.num) { // A、B、C、D

                break;
            }
            temp = temp.next;
        }
        addNode.next = temp.next;
        temp.next = addNode;
    }


    /**
     * 根据num 修改名字
     */
    public void upNode(int num, String name) {
        Node temp = headNode;
        while (true) {
            if (temp.next == null) {
                System.out.println("upNode  break 未找到可修改的数据");
                break;
            }
            if (temp.next.num == num) {
                temp.next.name = name;
                System.out.println("upNode = " + temp.next.name);
                break;
            }
            temp = temp.next;
        }
    }

    /**
     * delete
     * 根据num删除
     */
    public void delete(int num) {
        Node temp = headNode;
        while (true) {
            if (temp.next == null) {
                System.out.println("delete  break ");
                break;
            }
            if (temp.next.num == num) {
                // A、B、C  B是删除元素  A.next=C 即： A.next=A.next.next
                System.out.println("delete的元素 " + temp.next);
                temp.next = temp.next.next;
                break;
            }
            temp = temp.next;
        }
    }

    /**
     * 根据num 查处 对应的Node
     */
    public Node query(int num) {
        Node temp = headNode;
        Node tempNode = null;
        while (true) {
            if (temp.next == null) {
                System.out.println("query  break ");
                break;
            }
            if (temp.next.num == num) {
                tempNode = temp.next;
                System.out.println("query =  " + tempNode);
                break;
            }
            temp = temp.next;
        }

        return tempNode;

    }


    /**
     * 单链表反转
     */
    public void reverse() {
        // 分析1-->
        if (headNode == null || headNode.next == null || headNode.next.next == null) {
            // 空链表、链表只有一个元素 不用反转
            return;
        }
        Node temp = headNode;
        Node reverseHead = new Node(0, "");
        Node curNode = temp.next; // 当前链表
        Node nextNode; // 临时存储当前链表的下一个链表元素
        while (curNode != null) {
            // 先保存当前链表位置的下一个元素
            nextNode = curNode.next;
            // 分析 2-->
            /** 原链表：temp -> A.next -> B.next -> C.next ->D.next
             * 核心思路：遍历原链表时，每遍历一个元素
             *     1. next指针向后位移1位
             *     2. 同时把链表当前位置的元素给插入到 头节点是reverseHead的链表中，插在reverseHead最前端
             *         2.1 把拿到的元素的next指向原本reverseHead.next指向的数据
             *         2.2 然后把拿到当前的元素，都要插在新链表最前端：即：reverseHead.next指向的位置（头节点后的第一个节点）
             *         解释：  例如当前是 reverseHead.next -> A.next
             *                继续遍历拿到B时: 让B.next ->A.next
             *                               在让reverseHead.next ->B.next
             *                               这样形成 reverseHead.next ->B.next -> A.next
             * */
            curNode.next = reverseHead.next;
            reverseHead.next = curNode;
            // 分析3 --> 把原链表中下一个节点元素，赋值给当前curNode。（就是链表向后位移一位）
            curNode = nextNode;
        }
        //分析4 --> 原链表的头节点指向新链表头节点后的第一个元素（原表头节点替换掉新表头节点）
        // 解释 --> 新表头节点，于后面的节点断开，让原表头节点指向
        temp.next = reverseHead.next;

        // 最终完成单链表的反转
        try {
            showNode();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 单链表，反向打印节点
     * 遍历链表，逐个压入栈中（栈的数据结构先进后），在遍历栈，打印出来。结果符合反向打印链表
     */
    public void reversePrint() {

        Stack<Node> stack = new Stack<>();
        Node curNode = headNode.next;
        while (curNode != null) {
            stack.push(curNode);
            curNode = curNode.next;
        }

        while (stack.size() > 0) {
            System.out.println("反向打印链表节点： " + stack.pop());
        }

    }

    /**
     * 单链表倒数第k个节点
     * 思路：1. 遍历链表计算出，有效节点size（头节点排除在外）
     *      2. 倒数K节点对应的节点： size-k
     *      解释：例如链表：head(头节点) -> A.next -> B.next ->C.next -> D.next
     *           head不是有效节点，所以head要排除在外
     *           上述链表有效节点是4个，取倒数第2节点，即C节点，是我们需要的。
     *           size-k=2  从第一个有效节点，往后位移2位，即：从当前A节点，位移2位，是C节点。 即倒数k节点数据
     * */

    public void getK_Node(int k){

        int size=getSize();

        if (k<=0 || k>size){
            return;
        }
        Node curNode = headNode.next;
        for (int i=0;i<size-k;i++){
            curNode=curNode.next;
        }
        log("倒数K节点数据  "+curNode);
    }

    public int getSize(){
        int size=0;
        Node curNode = headNode.next;
        while (curNode != null) {
            size++;
            curNode = curNode.next;
        }
        return size;
    }


    /**
     * 打印出当前链表的所有元素
     */
    public void showNode() throws InterruptedException {
        if (headNode.next == null) { // 空
            return;
        }
        Node temp = headNode.next; // 第一个元素
        while (true) {
            Thread.sleep(500);
            System.out.println("showNode " + temp);
            if (temp.next == null) {
                System.out.println("showNode  break ");
                break;
            }
            temp = temp.next;
        }
    }


    public static class Node {
        int num;
        String name;
        Node next;

        public Node(int num, String name) {
            this.num = num;
            this.name = name;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "num=" + num +
                    ", name='" + name +
                    '}';
        }
    }

}
Join下班了吗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【笔记整理】数组模拟单链表/双链表
萌新菜鸡码dog
09-27 151
为什么要使用数组模拟链表？ 链表常在面试中被问到。 但是在笔试题中，由于数据的规模在1w~10w级别，每次new一个Node速度很慢，导致程序无法在1s内跑完。用数组模拟链表，可以解决程序运行速度的问题。（用空间换时间） 链表的类型： 单链表：用于创建邻接表（常在树与图的问题中出现）； 双链表：用于优化某些问题。 单链表 一般结构体形式的单链表定义： struct Node{ int value; Node* next; }; 数组模拟的思想： 以下标index为指针，使用两个数组对分别记录单.
数据结构与算法(python)笔记整理
qq_37356854的博客
02-24 349
1.引入概念 1.1 第一次尝试 import time start_time=time.time() for a in range(0,1001): for b in range(0,1001): for c in range(0,1001): if a**2+b**2==c**2 and a+b+c==1000: print(...
每天一道LeetCode-----将链表每k个节点逆序一次
一个程序渣渣的小后院
10-25 2337
Swap Nodes in Pairs原题链接 Swap Nodes in Pairs 意思是将链表每两个节点互换位置，要求不能直接改变链表的值，只能改变next指针的方式交换 其实就是遍历一遍每两个交换即可，方法比较随意/** * Definition for singly-linked list. * struct ListNode { * int val; *
王道2023数据结构笔记
热门推荐
一顿吃不饱的博客
07-15 1万+
线性表的定义​线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为L=(a1,a2,…,ai,ai+1,…,an)​ai是线性表中的“第i个”元素线性表中的位序​a1是表头元素；an是表尾元素​除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继线性表的基本操作初始化表。构造一个空的线性表L，分配内存空间。销毁操作。插入操作。删除操作。...
数据结构-学习笔记整理
码python的Vinsmoke
06-14 726
算法 算法是计算机处理信息的本质，因为计算机程序本质上是一个算法来告诉计算机确切的步骤来执行一个指定的任务，一般的，当算法在处理信息时，会从输入设备或数据的存储地址来读取数据，把结果写入输出设备或某个存储地址供以后在调用。 算法是独立存在的一种解决问题方法的思想。 算法的五大特性 输入：算法具有0或者多个输入 输出：算法至少有1个或多个输出 有穷性：算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接受的时间内完成。 确定性：算法中的每一步都有确定的意义，不会出现二义性 可行性：算法的每
【尚硅谷】Java数据结构与算法详细整理笔记（附代码）更新中…………
Blue
10-31 1071
数据结构包括:线性结构和非线性结构 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的链式存储的线性表称为链表,链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息线性结构常见的有：数组、队列、链表和栈非线性结构包括：二维数组，多维数组，广义表，树结构，图结构 稀疏 sparsearray数组稀疏数组代码二维数组转稀疏数组的思路队列是一个有序列表代码模拟队列
数据结构之单链表_next域数据类型，就是这么简单
2401_83946722的博客
04-20 903
节点还有头结点没有删除，所以当循环走完，我们还需要让head节点置空，这样就是真正的把所有节点删除了。
Java数据结构与算法笔记[笔记整理](复习、查缺补漏)
SwaeLeeUknow的博客
10-10 1144
Java数据结构与算法 推荐刷题网站:LeeCode 算法书籍:《剑指offer》 切记：不要为了看而看,一定要自己理解,动手把代码敲一敲。 day01稀疏数组：稀疏数组、队列、环形队列 day02链表：单链表、双链表、环形链表、约瑟夫问题 单链表面试题：腾讯、百度、新浪单链表面试题 day03栈：综合计算器、多位运算符、前中后缀表达式、逆波兰表达式 day04递归：迷宫回溯、八皇后问题 day05排序算法：冒泡,选择,插入,希尔,快速,归并,基数排序 day06查找算法
数据结构学习笔记（含C语言代码）
呼叫冰河谷博客
09-27 1670
目录 1.线性表 2. 栈和队列 3.串 4.数组和广义表 5.树和二叉树 6.图 7.查找 8.内部排序 逻辑图： 其中：集合结构、树结构、图结构为非线性结构 1.线性表 定义：一个线性表是n个具有相同特性的数据元素的有限序列，线性表的元素仅限于原子项，原子是结构上不可分割的成分 1.1顺序存储结构：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构，通常用数组来描述顺序存储结构,下同 分类：数组 //线性表的顺序存储 #include <.
数据结构学习笔记——单链表
12-21
数据结构是计算机科学中至关重要的基础概念，它们用于有效地组织和管理数据，以便进行高效的存储、检索和操作。本文将深入探讨单链表这一常见数据结构，并与其他数据结构如数组进行对比。 单链表是一种线性数据结构...
数据结构-C语言版：单链表例题.ppt
06-06
数据结构-C语言版：单链表例题.ppt
数据结构链表：单链表的代码实现
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
数据结构学习笔记-单链表
02-16
总结来说，单链表是一种非连续存储的数据结构，其主要优点在于插入和删除操作的灵活性。通过VS2022，我们可以方便地编写、编译和调试链表操作的代码，从而深入理解和掌握这一重要数据结构。在实际编程中，理解并能...
数据结构学习总结.doc
05-13
"数据结构学习总结" 数据结构是计算机科学中的一门基础学科，涵盖了数据的表示、存储、操作和分析等方面的知识。数据结构的学习对于计算机科学与技术专业的学生来说至关重要。本文将对《数据结构与算法》课程的知识...
数据结构-＞线性结构-＞顺序存储-＞静态链表
qq_68495605的博客
07-20 250
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
插入和选择排序
c23856的博客
07-20 491
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
数据结构(5.2_3)——二叉树的存储结构
m0_65240792的博客
07-19 347
1%29%5D1。
数据结构（二叉树-1）
最新发布
2401_83968713的博客
07-20 1023
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值