【数据结构】关于单链表的面试题

已于 2022-05-12 15:48:23 修改
阅读量222 收藏
点赞数
分类专栏： 链表 数据结构 文章标签： 数据结构 链表 面试
于 2022-05-11 22:19:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40839718/article/details/124714374
版权

关于单链表的面试题

1、求单链表中有效节点的个数
2、查找单链表中的倒数第k个节点
3、单链表的反转
4、逆序打印链表信息

1、求单链表中有效节点的个数

1.1 代码编写

public class SingleLinedList_NodeNumber {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(4,"吴用","智多星");
        HeroNode hero4 = new HeroNode(3,"林冲","豹子头");
        SingleLikedList singleLikedList = new SingleLikedList();
        singleLikedList.addByOrder(hero1);
        singleLikedList.addByOrder(hero2);
        singleLikedList.addByOrder(hero3);
        singleLikedList.addByOrder(hero4);
        singleLikedList.show();
        System.out.println("有效节点个数："+singleLikedList.getLength(singleLikedList.getHead()));
    }
}
//定义SingleLinkedList来管理英雄
class SingleLikedList {
    //先初始化一个头节点，头节点不要动，不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");
    //返回头节点
    public HeroNode getHead(){
        return head;
    }
    public void addByOrder(HeroNode heroNode) {
        //因为head节点不能动，因此需要新建一个辅助变量temp,temp是位于添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;//flag标识添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {//说明temp在链表最后
                break;
            }
            if (temp.next.no > heroNode.no) {//位置找到，就在temp后面插入
                break;
            } else if (temp.next.no == heroNode.no) {//说明希望添加的heroNode的编号已然存在
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;//temp后移,遍历当前链表
        }
        //判断flag的值
        if (flag) {
            System.out.printf("准备插入节点的编号%d已经存在了，不能再插入\n", heroNode.no);
        } else//可以插入到链表中，在temp的后面
        {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
        //当退出while循环时，temp就指向了链表最后节点，将temp的next指向新的节点
        temp.next = heroNode;
    }

    //显示链表（遍历）
    public void show() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }
    //获取到单链表有效节点的个数（如果是带头节点的链表，需求不统计头节点）
    public static int getLength(HeroNode head){
        if(head.next == null){   //空链表
            return 0;
        }
        int length = 0;
        //定义一个辅助的变量
        HeroNode temp = head.next;
        while (temp != null){
            length++;
            temp = temp.next;//遍历
        }
        return length;
    }

}

//定义HeroNode类，每个HeroNode对象就是一个节点
class HeroNode{
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    //构造器
    public HeroNode(int no,String name,String nickname){
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }
    //重写toString方法
    public String toString() {
        return "HeroNode[no=" + no + ",name=" + name + ",nickname=" + nickname + "]";
    }
}

1.2 运行结果

在这里插入图片描述

2、查找单链表中的倒数第k个节点

2.1 解题思路

（1）编写一个方法，接收head节点，同时接收一个index；
（2）index表示是倒数第index个节点；
（3）先把链表从头到尾遍历，得到链表的总长度getLength；
（4）得到size后，从链表的第一个节点开始遍历（size-index）个。

2.1 代码编写

public class SingleLinedList_FindKNode {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(4,"吴用","智多星");
        HeroNode hero4 = new HeroNode(3,"林冲","豹子头");
        SingleLikedList singleLikedList = new SingleLikedList();
        singleLikedList.addByOrder(hero1);
        singleLikedList.addByOrder(hero2);
        singleLikedList.addByOrder(hero3);
        singleLikedList.addByOrder(hero4);
        singleLikedList.show();
        System.out.println("有效节点个数："+singleLikedList.getLength(singleLikedList.getHead()));
        System.out.println(singleLikedList.getKNode(singleLikedList.getHead(),2));
    }
}
//定义SingleLinkedList来管理英雄
class SingleLikedList {
    //先初始化一个头节点，头节点不要动，不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");

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

    public void addByOrder(HeroNode heroNode) {
        //因为head节点不能动，因此需要新建一个辅助变量temp,temp是位于添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;//flag标识添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {//说明temp在链表最后
                break;
            }
            if (temp.next.no > heroNode.no) {//位置找到，就在temp后面插入
                break;
            } else if (temp.next.no == heroNode.no) {//说明希望添加的heroNode的编号已然存在
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;//temp后移,遍历当前链表
        }
        //判断flag的值
        if (flag) {
            System.out.printf("准备插入节点的编号%d已经存在了，不能再插入\n", heroNode.no);
        } else//可以插入到链表中，在temp的后面
        {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
        //当退出while循环时，temp就指向了链表最后节点，将temp的next指向新的节点
        temp.next = heroNode;
    }

    //显示链表（遍历）
    public void show() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }

    //获取到单链表有效节点的个数（如果是带头节点的链表，需求不统计头节点）
    public static int getLength(HeroNode head) {
        if (head.next == null) {   //空链表
            return 0;
        }
        int length = 0;
        //定义一个辅助的变量
        HeroNode temp = head.next;
        while (temp != null) {
            length++;
            temp = temp.next;//遍历
        }
        return length;
    }

    //查找单链表中的倒数第K个节点
    public HeroNode getKNode(HeroNode head, int index) {
        if (head.next == null) {   //空链表
            return null;
        }
        //先做一个index数据检验
        int size = SingleLikedList.getLength(head);
        if (index <= 0 || index > size) {
            System.out.println("输入K值有误");
            return null;
        }
        HeroNode temp = head.next;
        int n = 0;
        //第二次遍历size-index位置
        while (true) {
            if (n == size - index) {
                break;
            }
            temp = temp.next;
            n++;
        }
        return temp;
    }
}
    //定义HeroNode类，每个HeroNode对象就是一个节点
    class HeroNode {
        public int no;
        public String name;
        public String nickname;
        public HeroNode next;//指向下一个节点

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

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

2.2 运行结果

在这里插入图片描述

3、单链表的反转

3.1 解题思路

思路:
（1）先定义一个节点reverseHead =new HeroNode()；
（2）从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端；
（3）原来的链表的head.next =reverseHead.next
第一次移动和第二移动示意如下图所示：
在这里插入图片描述
最终效果如下图所示
最终效果

3.2 代码编写

public class SingleLinedList_Reverse {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(4,"吴用","智多星");
        HeroNode hero4 = new HeroNode(3,"林冲","豹子头");
        SingleLikedList singleLikedList = new SingleLikedList();
        singleLikedList.addByOrder(hero1);
        singleLikedList.addByOrder(hero2);
        singleLikedList.addByOrder(hero3);
        singleLikedList.addByOrder(hero4);
        System.out.println("====反转前遍历链表信息====");
        singleLikedList.show();
        System.out.println("有效节点个数："+singleLikedList.getLength(singleLikedList.getHead()));
        singleLikedList.Reverse(singleLikedList.getHead());
        System.out.println("====反转后遍历链表信息====");
        singleLikedList.show();
    }
}
//定义SingleLinkedList来管理英雄
class SingleLikedList {
    //先初始化一个头节点，头节点不要动，不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");

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

    public void addByOrder(HeroNode heroNode) {
        //因为head节点不能动，因此需要新建一个辅助变量temp,temp是位于添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;//flag标识添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {//说明temp在链表最后
                break;
            }
            if (temp.next.no > heroNode.no) {//位置找到，就在temp后面插入
                break;
            } else if (temp.next.no == heroNode.no) {//说明希望添加的heroNode的编号已然存在
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;//temp后移,遍历当前链表
        }
        //判断flag的值
        if (flag) {
            System.out.printf("准备插入节点的编号%d已经存在了，不能再插入\n", heroNode.no);
        } else//可以插入到链表中，在temp的后面
        {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
        //当退出while循环时，temp就指向了链表最后节点，将temp的next指向新的节点
        temp.next = heroNode;
    }

    //显示链表（遍历）
    public void show() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }

    //获取到单链表有效节点的个数（如果是带头节点的链表，需求不统计头节点）
    public static int getLength(HeroNode head) {
        if (head.next == null) {   //空链表
            return 0;
        }
        int length = 0;
        //定义一个辅助的变量
        HeroNode temp = head.next;
        while (temp != null) {
            length++;
            temp = temp.next;//遍历
        }
        return length;
    }
    //删除节点
    public void delete(int no) {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        boolean flag = false;//flag标识是否找到需要删除节点的前一个节点，默认为false
        while (true) {
            //判断是否到链表最后
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no)//找到了需要删除节点的前一个节点
            {
                flag = true;
                break;
            }
            //将temp后移
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.printf("需要删除节点编号%d不存在", no);
        }
    }
    //反转链表
    public static void Reverse(HeroNode head){
        //判断链表是否为空或者只有一个节点，此时无需反转，直接返回
        if (head.next == null){
            System.out.println("链表为空，无法反转");
        }
        if (head.next.next == null){
            System.out.println("链表只有一个节点，无法反转");
        }
        //获得链表有效节点个数
        int size = SingleLikedList.getLength(head);
        HeroNode temp = head.next;
        HeroNode next = null;//指向当前节点temp的下一个节点
        HeroNode reverseHead = new HeroNode(0,null,null);
        //从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
        while (true){
            if(temp == null)//遍历到最后一个节点
            {
                break;
            }
            next = temp.next;//暂时保存当前节点的下一个节点
            temp.next = reverseHead.next; //将temp的下一个节点指向新的链表的最前端
            reverseHead.next = temp;
            temp = next;//遍历后移
        }
        head.next = reverseHead.next;
    }

}
//定义HeroNode类，每个HeroNode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

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

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

3.3 运行结果

在这里插入图片描述

4、从尾到头打印单链表

4.1 解题思路

利用栈的先进后出特点，实现逆序打印的效果，未破坏链表结构。

4.2 代码编写

import java.util.Stack;

public class SingleLinedList_ReversePrint {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(4,"吴用","智多星");
        HeroNode hero4 = new HeroNode(3,"林冲","豹子头");
        SingleLikedList singleLikedList = new SingleLikedList();
        singleLikedList.addByOrder(hero1);
        singleLikedList.addByOrder(hero2);
        singleLikedList.addByOrder(hero3);
        singleLikedList.addByOrder(hero4);
        System.out.println("====逆序打印前遍历链表信息====");
        singleLikedList.show();
        System.out.println("====逆序打印链表信息====");
        singleLikedList.ReversePrint(singleLikedList.getHead());
    }
}
//定义SingleLinkedList来管理英雄
class SingleLikedList {
    //先初始化一个头节点，头节点不要动，不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");

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

    public void addByOrder(HeroNode heroNode) {
        //因为head节点不能动，因此需要新建一个辅助变量temp,temp是位于添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;//flag标识添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {//说明temp在链表最后
                break;
            }
            if (temp.next.no > heroNode.no) {//位置找到，就在temp后面插入
                break;
            } else if (temp.next.no == heroNode.no) {//说明希望添加的heroNode的编号已然存在
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;//temp后移,遍历当前链表
        }
        //判断flag的值
        if (flag) {
            System.out.printf("准备插入节点的编号%d已经存在了，不能再插入\n", heroNode.no);
        } else//可以插入到链表中，在temp的后面
        {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
        //当退出while循环时，temp就指向了链表最后节点，将temp的next指向新的节点
        temp.next = heroNode;
    }

    //显示链表（遍历）
    public void show() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }

    //逆序打印
    public static void ReversePrint(HeroNode head) {
        //判断链表是否为空，此时无需逆序打印，直接返回
        if (head.next == null) {
            System.out.println("链表为空，无需逆序打印");
            return;
        }
        Stack<HeroNode> heroNodes = new Stack<HeroNode>();
        HeroNode temp = head.next;
        while (temp != null){
            heroNodes.push(temp);
            temp = temp.next;
        }
        while (heroNodes.size() != 0){
            System.out.println(heroNodes.pop());
        }
    }
}
//定义HeroNode类，每个HeroNode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

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

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

4.3 运行结果

在这里插入图片描述

dengmsjava
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构的一些面试题.pdf
05-07
将数据结构的面试题分为基础知识、中级知识和高级知识三个部分： ### 基础知识 (1-20) 1. 解释数组和链表的区别。 2. 如何在单链表中找到中间的元素？ 3. 解释栈和队列的区别及其应用。 4. 在二叉树中如何进行前序...
算法大全面试题数据结构单链表的13道面试题含代码
12-17
算法大全面试题数据结构单链表的13道面试题含代码 1.单链表反转 2.找出单链表的倒数第四个元素 3.找出单链表的中间元素 4...
【数据结构与算法 4】单链表面试题
学Java，找哪吒
05-13 3498
一、获取到单链表的节点的个数 /* * head 链表的头节点 * 返回有效节点的个数,没有统计头节点 * */ public static int getLength(HeroNode head) { if(head.next == null) { return 0; } int length = 0; //定义一个辅助变量 HeroNode cur = head.next; while(cur != null) { length++; cur = cur.next;
单链表相关的面试题
weixin_44834926的博客
10-27 89
面试题1：删除值为key的所有节点 要求只遍历一遍 public Node removeAllKey(int key) { if (this.head == null) { return null; } Node prev = this.head; Node cur = this.head.next; while (cur != null) { if (cur.data
数据结构-单链表相关面试题
mxrrr_sunshine的博客
03-27 283
从尾到头打印单链表我们在学习递归时，曾经遇到过这样一道题目，打出1234的每一位数，那么我们用递归的思想是：打印1234，就要打出123+4，接下来是12+3+4,在然后1+2+3+4，就能打印每一位数，显然是将一个复杂问题拆解为一个个小问题。 那么同理逆序打印单链表也是，先打最后一个然后以此类推。直接上代码。void LinkListReversePrint(LinkNode* head) {
Java数据结构与算法-链表(单链表、双向链表、环形链表、约瑟夫问题)[day02]
SwaeLeeUknow的博客
09-04 471
day02-链表 单链表介绍和内存布局 链表是有序的列表，但是内存中是实际存储结构如下： 小结: 1.链表是以节点的方式来存储,是链式存储(即各个节点之间并不一定是连续存储的，而是相互指向的); 2.每个节点包含 data 域:存放数据的域， next 域：指向下一个节点; 3.如图：发现链表的各个节点不一定是连续存储; 4.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定. 单链表(带头结点) 逻辑结构示意图如下: 单链表创建和遍历的分析实现 例子 使用带head头的单向
单链表面试题
weixin_45894950的博客
11-30 99
/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode removeElements(ListNode head, int val) { if(head == null)..
Java数据结构与算法-单链表 新浪，腾讯面试题详解
12-22
单链表常见的几个面试题 新浪，腾讯内部面试题目 题目分析 代码实现 测试用例 一，面试题目 统计链表中有效节点的个数（不含头结点）【新浪】 获取链表中倒数第K个元素【新浪】 单向链表的逆转【腾讯】 二，题目分析...
（Python3）数据结构–单链表之计算两数之和
12-22
有数据结构单链表基础，不清楚的参考前面的博客 链接： https://blog.csdn.net/sf9898/article/details/104946291 问题描述 这是某大厂的面试题，现场写代码的那种。 给出两个非空的链表，用来表示两个非负的整数，...
单链表的相关面试题（一）
小心眼儿猫的博客
04-07 293
以下内容接《C语言实现单链表的增删查改》有需要者自行戳链接查看 linklist.h文件新增内容 //冒泡排序 void linklistBubbleSort(LinkNode *head); //找出中间节点 LinkNode *FindMidNode(LinkNode *head); //找倒数第K个节点 LinkNode *FindLastKNode(LinkNode *head,siz...
【单链表面试题】
qq_25355771的博客
04-24 211
面试题常见的面试题基础代码求单链表中有效节点的个数查找单链表中倒数第k个节点 [新浪]链表的反转 [腾讯]从尾到头打印单链表 [百度，要求：1.反向遍历；2.stack栈]合并两个有序的单链表，合并之后的链表依然有序。 常见的面试题 基础代码 代码： package Package01; public class SingleLinkedListDemo { public static void main(String[] args) { // 进行测试 // 先创建节
单链表面试题（一）
Hlun的博客
08-02 650
链表是最基本的数据结构，链表的相关操作也比较简单，同时它也包含了指针的运用，能把许多知识结合起来，因此链表的面试题在面试中占据很重要的地位，所以我整理了一些关于链表的面试题与大家分享。下图是其中一道求带环链表入口点题的分析图
数据结构与算法面试题java
最新发布
03-29
当然，我可以为您介绍一些常见的数据结构与算法面试题。以下是一些常见的数据结构与算法面试题及其解答： 1. 请解释什么是数组？ 数组是一种线性数据结构，它由相同类型的元素组成，并按照一定的顺序存储在连续的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值