数据结构与算法-单链表面试题

已于 2024-05-02 00:20:58 修改
阅读量398 收藏 1
点赞数 12
分类专栏： 我的dhu记录 数据结构与算法学习 文章标签： java 算法 学习方法 数据结构 链表
于 2024-05-01 23:07:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nameofworld/article/details/138381975
版权

题一：获取单链表节点的个数

思路

在HeroNode类中写一个方法public static int getLength(HeroNode head)获取节点个数。如果是带头节点就不统计头节点。

如果head节点的next为null就返回0.否则定义一个length变量用于计数，定义一个辅助变量current，current=head.next，然后循环中只要current不为null就把length加1，再把current后移。循环结束后返回的length就是节点的个数。

方法代码：

//获取单链表的节点个数，如果是带头节点的链表就不统计头节点
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            //为空链表则直接返回0
            return 0;
        }
        int length = 0;//统计有效节点个数
        //辅助变量用于遍历
        HeroNode current = head.next;
        while (current != null) {
            length++;
            current = current.next;
        }
        return length;
    }

由于SingleLinkedList中头节点是私有的，所以要获取头节点还需要在SingleLinkedList类中写一个方法获取头节点。

//先初始化头节点，不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");

    //返回头节点
    public HeroNode getHead() {
        return head;
    }

在main方法中

System.out.println("节点个数：" + getLength(singleLinkedList1.getHead()));

运行结果：

题二：查找单链表的倒数第k个节点

思路

编写一个方法，接收head节点，同时接收index（倒数第index个节点）。先把链表从头到尾遍历，得到链表总长Length。得到Length后，从链表第一个节点开始遍历Length-index个节点。比如总共3个节点，要查倒数第一个节点就从第一个节点开始遍历2个节点。使已经知道要遍历几个节点就用for循环，找到了就返回该节点，找不到就返回null。

方法代码

//获取单链表倒数第K个节点
    public static HeroNode findLastIndexNode(HeroNode head,int index){
        //判断链表是否为空
        if(head.next==null){
            return null;
        }
        //先遍历得到节点个数
        int Length=getLength(head);
        //再遍历到size-index
        if(index<=0||index>Length){
            return null;//不合适的index就返回null
        }
        //定义辅助变量temp
        HeroNode temp=head.next;
        for(int i=0;i<Length-index;i++){
            temp=temp.next;
        }
        return temp;
    }

在main方法中

HeroNode res=findLastIndexNode(singleLinkedList1.getHead(),1);
System.out.println("倒数第1个节点为："+res);

运行结果：

完整代码：

package com.xjj.linkedlist;

public class LinkedList {
    public static void main(String[] args) {
        //创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //将节点加入链表
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        //显示链表
        singleLinkedList.list();
        System.out.println("按编号顺序插入");
        SingleLinkedList singleLinkedList1 = new SingleLinkedList();
        //将节点插入链表
        singleLinkedList1.addByOrder(hero1);
        singleLinkedList1.addByOrder(hero4);
        singleLinkedList1.addByOrder(hero2);
        singleLinkedList1.addByOrder(hero3);
        singleLinkedList1.list();
        //测试修改节点
        System.out.println("修改节点");
        HeroNode newHeroNode = new HeroNode(2, "卢", "玉麒麟--");
        singleLinkedList1.update(newHeroNode);
        singleLinkedList1.list();
        //测试删除节点
        System.out.println("删除节点1");
        singleLinkedList1.delete(1);//删除第一个节点
        singleLinkedList1.list();
        System.out.println("删除节点4");
        singleLinkedList1.delete(4);//删除第四个节点
        singleLinkedList1.list();
//        System.out.println("删完");
//        singleLinkedList1.delete(2);//删除第二个节点
//        singleLinkedList1.delete(3);//删除第三个节点
//        singleLinkedList1.list();
        System.out.println("节点个数：" + getLength(singleLinkedList1.getHead()));
        HeroNode res=findLastIndexNode(singleLinkedList1.getHead(),1);
        System.out.println("倒数第1个节点为："+res);
    }

    //获取单链表的节点个数，如果是带头节点的链表就不统计头节点
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            //为空链表则直接返回0
            return 0;
        }
        int length = 0;//统计有效节点个数
        //辅助变量用于遍历
        HeroNode current = head.next;
        while (current != null) {
            length++;
            current = current.next;
        }
        return length;
    }
    //获取单链表倒数第K个节点
    public static HeroNode findLastIndexNode(HeroNode head,int index){
        //判断链表是否为空
        if(head.next==null){
            return null;
        }
        //先遍历得到节点个数
        int Length=getLength(head);
        //再遍历到size-index
        if(index<=0||index>Length){
            return null;//不合适的index就返回null
        }
        //定义辅助变量temp
        HeroNode temp=head.next;
        for(int i=0;i<Length-index;i++){
            temp=temp.next;
        }
        return temp;
    }
}

//英雄类
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    //构造器
    public HeroNode(int hNo, String hName, String hNickname) {
        this.no = hNo;
        this.name = hName;
        this.nickname = hNickname;
    }

    //重写toString来显示方法
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    }
}

//管理英雄类
class SingleLinkedList {
    //先初始化头节点，不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");

    //返回头节点
    public HeroNode getHead() {
        return head;
    }

    //添加节点。不考虑编号顺序时，先找到当前链表的最后节点，再将这个节点的next指向新节点
    public void add(HeroNode heroNode) {
        //辅助遍历temp
        HeroNode temp = head;
        //遍历链表找到最后
        while (true) {
            if (temp.next == null) {//找到最后了就退出
                break;
            }
            //没到最后就后移到下一个节点
            temp = temp.next;
        }
        //退出while循环时temp就指向链表最后
        //我们要添加新节点，就将这个最后节点的next指向节点
        temp.next = heroNode;
    }

    //添加节点，考虑编号顺序。也就是插入到链表非末尾位置
    public void addByOrder(HeroNode heroNode) {
        //辅助变量位于添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;//标识添加的编号是否存在。如果存在就不能添加了
        while (true) {
            if (temp.next == null) {
                //已经在链表最后，要添加的节点可能已经在链表最后
                break;
            }
            if (temp.next.no > heroNode.no) {
                //temp下一个节点的编号大于要插入的节点编号，就是找到了，要在这个temp后面插入
                break;
            } else if (temp.next.no == heroNode.no) {
                //编号已存在
                flag = true;//编号存在
            }
            temp = temp.next;//后移
        }
        //判断编号是否已存在
        if (flag) {
            System.out.printf("准备插入的编号 %d 已经存在，无法添加\n", heroNode.no);
        } else {
            //新节点插入链表中temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;//temp后面是新节点
        }
    }

    //根据编号修改节点信息，即编号不能修改
    public void update(HeroNode newHeroNode) {
        //判断链表是否为空
        if (head.next == null) {
            //如果链表为空就不遍历了
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点
        //辅助变量
        HeroNode temp = head.next;
        boolean flag = false;//判断是否找到该节点
        while (true) {
            if (temp == null) {
                break;//已经遍历完链表
            }
            if (temp.no == newHeroNode.no) {
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //判断是否找到节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            System.out.printf("没有找到编号为 %d 的节点\n", newHeroNode.no);
        }
    }

    //删除节点
    public void delete(int no) {
        //判断链表是否为空
        if (head.next == null) {
            //如果链表为空就不遍历了
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点
        //辅助变量
        HeroNode temp = head;
        boolean flag = false;//判断是否找到该节点
        while (true) {
            if (temp.next == null) {
                break;//已经遍历完链表
            }
            if (temp.next.no == no) {
                //找到待删除节点的前一个节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //判断是否找到节点
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.printf("没有找到编号为 %d 的节点\n", no);
        }
    }

    //显示链表，看有没有成功
    public void list() {
        //判断链表是否为空，如果为空就不遍历了
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //不为空就遍历
        //使用辅助变量来遍历
        HeroNode temp = head.next;//这里指向的是下一个
        while (true) {
            //看是否到链表最后
            if (temp == null) {
                break;
            }
            //不为空就输出节点信息
            System.out.println(temp);
            //后移
            temp = temp.next;
        }
    }
}

运行结果：

题三：反转单链表

原链表：

反转后：

思路

先定义一个节点reverseHead=newHeroNode()，再遍历原来的链表，遍历一个节点就取出一个节点，放到新链表的最前端。最后使原来链表的head.next=reverseHead.next，就连上了。

一个辅助变量temp，指向要取出的节点之后把temp后移一个然后把节点取出来，把reverseHead节点与刚取出的节点连起来。

如图先把第一个节点获取之后接到reverseHead节点后面，temp已经移到了第二个节点。

再把获取的第二个节点接到reverseHead节点后面，第二个节点的next变成原来的第一个节点。

再把获取的第三个节点接到reverseHead节点后面，第三个节点的next变成原来的第二个节点。

最后把原head节点的next指向reverseHead节点的后面的第一个节点。那么从head节点开始遍历的时候也不会遍历到reverseHead节点。成功实现了链表反转。

关键代码：

//将链表反转
    public static void reverseList(HeroNode head) {
        //当前链表为空或只有一个节点就不需要反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        //定义辅助变量遍历原来的链表
        HeroNode current = head.next;
        HeroNode curNext = null;//指向当前节点current的下一个节点
        HeroNode reverseHead = new HeroNode(0, "", "");
        //遍历原来的链表，遍历一个节点就取出一个节点放在新链表reverseHead最前面
        while (current != null) {
            curNext = current.next;//暂时保存当前节点的下一个节点
            current.next = reverseHead.next;//将current的下一个节点指向新链表的最前端，就是新链表头节点后面的第一个节点
            reverseHead.next=current;//将current连接到新链表上
            current=curNext;//当前节点后移一个
        }
        //while这里结束之后就实现了完整的新链表
        //将head.next指向reverseHead.next
        head.next=reverseHead.next;
    }

在main中：

//测试链表反转

singleLinkedList.list();

System.out.println("反转后：");

reverseList(singleLinkedList.getHead());

singleLinkedList.list();

反转单链表完整代码：

package com.xjj.linkedlist;

public class LinkedList {
    public static void main(String[] args) {
        //创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

       //将节点加入链表
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        //测试链表反转
        singleLinkedList.list();
        System.out.println("反转后：");
        reverseList(singleLinkedList.getHead());
        singleLinkedList.list();
    }
    //将链表反转
    public static void reverseList(HeroNode head) {
        //当前链表为空或只有一个节点就不需要反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        //定义辅助变量遍历原来的链表
        HeroNode current = head.next;
        HeroNode curNext = null;//指向当前节点current的下一个节点
        HeroNode reverseHead = new HeroNode(0, "", "");
        //遍历原来的链表，遍历一个节点就取出一个节点放在新链表reverseHead最前面
        while (current != null) {
            curNext = current.next;//暂时保存当前节点的下一个节点
            current.next = reverseHead.next;//将current的下一个节点指向新链表的最前端，就是新链表头节点后面的第一个节点
            reverseHead.next=current;//将current连接到新链表上
            current=curNext;//当前节点后移一个
        }
        //while这里结束之后就实现了完整的新链表
        //将head.next指向reverseHead.next
        head.next=reverseHead.next;
    }
}

//英雄类
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    //构造器
    public HeroNode(int hNo, String hName, String hNickname) {
        this.no = hNo;
        this.name = hName;
        this.nickname = hNickname;
    }

    //重写toString来显示方法
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    }
}

//管理英雄类
class SingleLinkedList {
    //先初始化头节点，不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");

    //返回头节点
    public HeroNode getHead() {
        return head;
    }

    //添加节点。不考虑编号顺序时，先找到当前链表的最后节点，再将这个节点的next指向新节点
    public void add(HeroNode heroNode) {
        //辅助遍历temp
        HeroNode temp = head;
        //遍历链表找到最后
        while (true) {
            if (temp.next == null) {//找到最后了就退出
                break;
            }
            //没到最后就后移到下一个节点
            temp = temp.next;
        }
        //退出while循环时temp就指向链表最后
        //我们要添加新节点，就将这个最后节点的next指向节点
        temp.next = heroNode;
    }

    //显示链表，看有没有成功
    public void list() {
        //判断链表是否为空，如果为空就不遍历了
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //不为空就遍历
        //使用辅助变量来遍历
        HeroNode temp = head.next;//这里指向的是下一个
        while (true) {
            //看是否到链表最后
            if (temp == null) {
                break;
            }
            //不为空就输出节点信息
            System.out.println(temp);
            //后移
            temp = temp.next;
        }
    }
}

运行结果

加油加油^_^

nameofworld
关注
专栏目录
数据结构单链表面试题
ChenMeng9的博客
09-29 192
1 单链表如何逆置 逆置1 ：一直头插即可 bool Reverse(PNode plist) { assert(plist!=NULL); Node *p=plist->next; Node*q; plist->next=nullptr; //让头结点断开，方便尾部为空。 while(p!=NULL) { q=p->next; p->next=plst->next; plist->next=p; p=q; } ..
数据结构与算法7——单链表小结（腾讯面试题）
Shallwen_Deng的博客
08-03 379
题目：快速找到未知长度单链表的中间结点。 既然是面试题就一定有普通方法和高级方法，而高级方法无疑会让面试官大大加分！ 普通的方法很简单，首先遍历一遍单链表以确定单链表的长度L。然后再次从头结点出发循环L/2次找到单链表的中间结点。 算法复杂度为：O(L+L/2)=O(3L/2)。 能否再优化呢？有一个很巧的方法：利用快慢指针！ 利用快慢指针原理：设置两个指针*search、 *mid 都指向单链表...
Java-数据结构与算法--单链表面试题(新浪，百度，腾讯)
weixin_45508650的博客
08-14 135
注：本文结合[单链表增删改查]使用 (点击前往) 单链表常见面试题如下： 1.求单链表中有效节点的个数 2.查找单链表中的倒数第K个节点（新浪面试题） 3.单链表的反转（腾讯面试题） 4.从尾到头打印单链表（百度要求1，反转遍历 2，Stack栈） 5，合并两个有序的单链表，合并之后的链表依然有序 1.求单链表中有效节点的个数 //方法：获取单链表的节点个数（如果是带头节点的链表，需求不统计头节点） //head链表的头节点 //return 返回的就是有效节点的个数 public
数据结构与算法day06-单链表面试题讲解(新浪、百度、腾讯)
深耕java的博客
11-28 422
单链表的常见面试题如下： 1.求单链表中节点的个数 2.查找单链表中的倒数第K个节点【新浪面试题】 3.单链表的反转【腾讯面试题】 4.从尾到头打印单链表【百度，要求方式1：反向遍历。方式2：stack栈】 5.合并两个有序的单链表，合并之后的链表依然有序【课后练习】 ...
java程序-单链表面试题（求有效节点数；查找第K个结点；单链表反转）
不知谓
08-18 220
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np impor..
数据结构与算法期末复习——知识点+题库
软件手的博客
05-12 9174
大学生 数据结构期末复习——知识点+题库 四川轻化工
2020年春季学期数据结构与算法第一次统一测试1
08-03
本次测试主要涵盖了数据结构与算法的相关知识，特别是链表的操作以及地理位置计算的算法。下面将对涉及的关键知识点进行详细说明。 首先，数据结构是计算机存储、组织数据的方式，它是算法的基础。在这个测试中，...
spring事务详细讲解-深入浅出
小电玩
09-08 533
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1517
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
yang_brother的博客
09-10 580
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 613
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 571
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
Linux服务器Java启动脚本
Jack魏
09-08 571
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
MyBatis面试
Tony_yitao的博客
09-09 786
MyBatis面试
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 366
步骤很详细，直接上教程……
Spring-di基本使用
2301_76862031的博客
09-09 1380
spirngDi环境搭建，使用流程，set注入，构造注入，对象注入，外部引入注入，内部创建注入，外部引入级联赋值注入，list集合注入，map集合注入，util注入
Spring AMQP给消息添加头信息
yong472727322的博客
09-10 236
【代码】Spring AMQP给消息添加头信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值