数组，队列与链表（详细，单链表的面试题）

最新推荐文章于 2023-04-25 23:17:20 发布
最新推荐文章于 2023-04-25 23:17:20 发布
阅读量263 收藏
点赞数 1
分类专栏： Java 数据结构与算法 学习笔记 文章标签： 队列 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhao_to/article/details/117091171
版权

稀疏数组

基本介绍

当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方法是:

1)记录数组一共有几行几列，有多少个不同的值

2)把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

案例：

1)使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)

2)把稀疏数组存盘，并且可以从新恢复原来的二维数组数

3)整体思路分析

在这里插入图片描述

4)代码实现

package com.zhao.sparsearray;

public class SparseArray {
    public static void main(String[] args) {
        //创建一个原始的二维数组 11*11
        //0:表示没有棋子，1表示黑子 2表蓝子
        int chessArr1[][] = new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][3]=2;
        chessArr1[5][5]=2;
        chessArr1[4][4]=1;
        //输出原始的二位数组
        System.out.println("原始的二位数组");
        for (int[] row : chessArr1){
            for (int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

        //将二维数组转稀疏数组的步骤
        //1.先遍历二维数组得到非0数据的个数
        int sum = 0;
        for (int i = 0;i<11;i++){
            for (int j=0;j<11;j++){
                if (chessArr1[i][j] != 0){
                    sum++;
                }
            }
        }

        //2.创建对应的稀疏数组
        int sparseArr[][] = new int[sum+1][3];
        //给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum ;

        //遍历二维数组，将非0的值存放到 sparseArr中
        int count = 0;//count,用于记录是第几个非0数据
        for (int i = 0;i<11;i++){
            for (int j = 0;j<11;j++){
                if (chessArr1[i][j] != 0){
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }

        //输出稀疏数组的形式
        System.out.println();
        System.out.println("得到的稀疏数组为-----");
        for (int i=0;i<sparseArr.length;i++){
            System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }

        //将稀疏数组--》恢复成原始的二维数组
        //1.先读取稀疏数组的第-行，根据第一行的数据，创建原始的二维数组，比如上面的ChessArr 2=int[11][11]
        //2.在读取稀疏数组后几行的数据，并赋给原始的二维数组即可。


        //1。先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];

        //2.在读取稀疏数组后几行的数据(从第二行开始),并赋给原始的二维数组即可
        for (int i=1;i<sparseArr.length;i++){
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        //输出二维数组
        System.out.println("转换的二位数组");
        for (int[] row : chessArr2){
            for (int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }


    }
}

队列

介绍：

队列是一个有序列表，可以用数组或是链表来实现。

遵循先入先出的原则。即:先存入队列的数据，要先取出。后存入的要后取出

使用场景：

​ 银行排队案例

数组模拟队列

队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图,其中maxSize是该队列的最大容量。

因为队列的输出、 输入是分别从前后端来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front 会随着数据输出而改变，而rear则是随着数据输入而改变,如图所示:

在这里插入图片描述

package com.zhao.queue;

import java.util.Scanner;

public class ArrayQueueDemo {
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(3);
        char key = ' '; //接受用户输入
        Scanner scanner = new Scanner(System.in);
        boolean flag = true;

        while (flag){
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):从队列取出数据");
            System.out.println("h(head):查看队列头的数据");
            key = scanner.next().charAt(0);//接受一个字符
            switch (key){
                case 's':
                    queue.show();
                    break;
                case 'e':
                    flag = false;
                    break;
                case 'a':
                    System.out.println("请输入一个数：");
                    int num = scanner.nextInt();
                    queue.addQueue(num);
                    break;
                case 'g':
                    try {
                        int value = queue.getQueue();
                        System.out.println(value);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int value = queue.headQueue();
                        System.out.println(value);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

//使用数组模拟队列 - 编写一个ArrayQueue类
class ArrayQueue{
    private int maxSize;//表示数组的最大容量
    private int front;  //队列头
    private int rear;   //队列尾
    private int[] arr;  //用来存放数据，模拟队列

    //创建队列
    public ArrayQueue(int arrMaxSize){
        this.maxSize = arrMaxSize;
        this.arr = new int[maxSize];
        this.front = -1; //指向队列头部，分析出front是指向队列头的前一个位置
        this.rear = -1;  //指向队列尾，指向队列尾的数据(即就是队列最后一个数据)

    }

    //判断队列是否满
    public boolean isFull(){
        return rear == maxSize-1;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return front == rear;
    }

    //向队列添加数据
    public  void addQueue(int num){
        if (isFull()){
            System.out.println("队列满了");
        }else {
            rear++;
            arr[rear] = num;
        }

    }

    //从队列取数据
    public int getQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，没有数据");
        }else {
            front++;
            return arr[front];
        }

    }

    //显示队列的所有数据
    public void show(){
        if (isEmpty()){
            System.out.println("队列为空，没有数据");
        }else {
            for (int i=0;i<arr.length;i++){
                System.out.print("第"+(i+1)+"个数据："+arr[i]);
                System.out.println();
            }
        }
    }

    //显示对列的头数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，没有数据");
        }else {
            return arr[front+1];
        }
    }

}

问题分析并 优化

1)目前数组使用一次就不能用，没有达到复用的效果

2)将这个数组使用算法，改进成一个环形的取模%

数组模拟环形队列

对前面的数组模拟队列的优化，充分利用数组因此将数组看做是一个环形的。

1）尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定，这个在做判断队列满的时候需要注意(rear+ 1)% maxSize == front 满
2）rear== front [空]
3）分析示意图

在这里插入图片描述

代码实现：

package com.zhao.queue;

import java.util.Scanner;

public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        System.out.println("测试数组模拟环形队列的案例------");
        CircleArrayQueue queue = new CircleArrayQueue(4);//设置4，有效数据最大为3
        char key = ' '; //接受用户输入
        Scanner scanner = new Scanner(System.in);
        boolean flag = true;

        while (flag){
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):从队列取出数据");
            System.out.println("h(head):查看队列头的数据");
            key = scanner.next().charAt(0);//接受一个字符
            switch (key){
                case 's':
                    queue.show();
                    break;
                case 'e':
                    flag = false;
                    break;
                case 'a':
                    System.out.println("请输入一个数：");
                    int num = scanner.nextInt();
                    queue.addQueue(num);
                    break;
                case 'g':
                    try {
                        int value = queue.getQueue();
                        System.out.println(value);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int value = queue.headQueue();
                        System.out.println(value);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}
//使用数组模拟队列 - 编写一个ArrayQueue类
class CircleArrayQueue{
    private int maxSize;//表示数组的最大容量
    //front的初始值= 0
    private int front;  //1. front 变量的含义做一个调整: front 就指向队列的第一个元素, 也就是说arr[front]就是队列的第一个元素

    //rear的初始值= 0
    private int rear;   //2. rear 变量的含义做一个调整: rear 指向队列的最后一个元素的后一个位置.因为希望空出一个空间做为约定.

    private int[] arr;  //用来存放数据，模拟队列

    //创建队列
    public CircleArrayQueue(int arrMaxSize){
        this.maxSize = arrMaxSize;
        this.arr = new int[maxSize];
        this.front = 0;
        this.rear = 0;
    }

    //判断队列是否满
    public boolean isFull(){
        return (rear+1)%maxSize == front;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return front == rear;
    }

    //向队列添加数据
    public  void addQueue(int num){
        if (isFull()){
            System.out.println("队列满了");
        }else {
            //直接加入数据
            arr[rear] = num;
            //将rear 后移，这里必须考虑取模
            rear = (rear + 1) % maxSize;
        }

    }

    //从队列取数据
    public int getQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，没有数据");
        }else {
            int value = arr[front];
            front = (front + 1) % maxSize;
            return value;
        }

    }

    //显示队列的所有数据
    public void show(){
        if (isEmpty()){
            System.out.println("队列为空，没有数据");
        }else {
            //思路：从front开始遍历，遍历多少个元素
            //有效数据数：（rear + maxSize - front)%maxSize
            for (int i=front;i<front+size();i++){
                System.out.print("arr["+(i%maxSize)+"]："+arr[(i%maxSize)]);
                System.out.println();
            }
        }
    }

    public int size(){
        //rear = 1
        //front = 0
        //maxSize = 3
        //有效值 1
        return (rear+maxSize-front)%maxSize;
    }

    //显示对列的头数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，没有数据");
        }else {
            return arr[front];
        }
    }

}

链表（Linked List）

单项链表
链表是有序的列表
  • 链表是以节点的方式来存储，是链式存储
  • 每个节点包含data域，next域: 指向下一个节点.
  • 发现链表的各个节点不一定是连续存储
  • 链表分带头结点的链表，和没有头节点的链表
应用实例

使用带head头的单向链表实现 - 水浒英雄排行榜管理

1)完成对英雄人物的增删改查操作，注: 删除和修改,查找

2)第一种方法在添加英雄时，直接添加到链表的尾部

在这里插入图片描述

3)第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)

在这里插入图片描述

删除

在这里插入图片描述

代码实现
package com.zhao.linkedlist;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(2,"晁盖","托塔天王");
        HeroNode heroNode3 = new HeroNode(3,"卢俊义","玉麒麟");
        HeroNode heroNode4 = new HeroNode(4,"林冲","豹子头");
        HeroNode heroNode5 = new HeroNode(4,"赵童","豹子头");

        SingleLinkedList linkedList = new SingleLinkedList();
        System.out.println("按顺序添加的：");
        linkedList.addByOrder(heroNode1);
        linkedList.addByOrder(heroNode2);
        linkedList.addByOrder(heroNode4);
        linkedList.addByOrder(heroNode3);
        linkedList.list();

        System.out.println("修改后的链表：");
        linkedList.update(heroNode5);
        linkedList.list();

        System.out.println("删除后的链表：");
        linkedList.del(4);
        linkedList.list();
    }
}


//定义SingleLinkedList管理我们的英雄
class SingleLinkedList{
    //先初始化一个头节点，头节点不要动，不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单向链表
    //思路，当不考虑编号顺序时
    //1.找到当前链表的最后节点
    //2.将最后这个节点的next 指向新的节点
    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true){
            //找到链表的最后
            if (temp.next == null){
                break;
            }
            //如果没找到最后，将temp后移
            temp = temp.next;
        }

        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;

    }

    //第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    //(如果有这个排名,则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode){
        //因为头节点不能动，因此我们仍然通过-个辅助指针(变量)来帮助找到添加的位置
        //因为单链表，因为我们找的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){//说明已经存在
                flag = true;
                break;
            }

            temp=temp.next;//后移，遍历当前链表
        }

        //判断flag的值
        if (flag){//不能添加，说明编号存在
            System.out.println("编号为"+heroNode.no+"的英雄已经存在了");

        }else {
            //插入到链表中，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }


    //修改节点的信息，根据no编号来修改，即no编号不能改
    //1.根据 newHeroNode 的 no 来修改即可
    public  void update(HeroNode newHeroNode){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }

        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false;//表示是否找到该节点
        while (true){
            if (temp == null){
                break;//已经遍历完链表
            }
            if (temp.no == newHeroNode.no){
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag 判断是否找到要修改的节点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else {
            System.out.println("没有这位英雄");
        }


    }

    //删除节点
    //思路
    //1.head不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2.说明我们在比较时:,是temp.next.no和需要删除的节点的no比较
    public void del(int no){
        HeroNode temp = head;
        boolean flag = false;//标志是否找到待删除节点时
        while (true){
            if (temp.next == null){//已经到链表的最后
                break;
            }
            if (temp.next.no == no){
                //找到的待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next; // temp后移，遍历
        }
        if (flag){//找到
            //可以删除
            temp.next = temp.next.next;
        }else {
            System.out.println("没有这个英雄");
        }
    }



    //显示链表【遍历】
    public void list(){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要一个辅助遍历temp
        HeroNode temp = head.next;
        while (true){
            //判断是否到链表最后
            if (temp == null){
                break;
            }

            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.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;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

1)求单链表中节点的个数

//方法：获取到单链表的节点的个数（如果是带头节点的链表，需要不统计头节点）
    /**
     * @param head 传入头节点
     * @return int
     */
    public static int getLength(HeroNode head){
        if (head.next == null){//空链表
            return 0;
        }
        //定义一个辅助的变量，我们没有統計头节点
        HeroNode cur = head.next;
        int length = 0;
        while (cur != null){
            length++;
            cur = cur.next;//遍历
        }
        return length;
    }

2)查找单链表中的倒数第k个结点

 //查找单链表中的倒数第k个结点[ 新浪面试题]
    //思路
    //1.编写一个方法，接收head节点,同时接收一个index
    //2. index 表示是倒数第index个节点
    //3.先把链表从头到尾遍历，得到链表的总的长度getLength
    //4.得到size 后，我们从链表的第-个开始遍历(size-index)个，就可以得到
    //5.如果找到了,则返回该节点，否则返null
    public static HeroNode findLastIndexNode(HeroNode head,int index){
        //判断链表为空，返回 null
        if (head.next == null){
            return null;//没有找到
        }
        //第一个遍历得到链表的长度（节点个数）
        int size = getLength(head);
        //第二次遍历 size-index 位置，就是我们倒数的第K个节点
        //做一个index的校验
        if (index <= 0 || index > size){
            return null;
        }
        //先定义辅助变量，for循环定位到倒数的index
        HeroNode cur = head.next;
        for (int i = 1;i <= size-index;i++){
            cur = cur.next;
        }
        return cur;
    }
  1. 单链表的反转
//反转单链表
    public static void reverserList(HeroNode head){
        //如果当前链表为空,或者只有一一个节点，无需反转，直接返回
        if (head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助变量，帮助我们遍历原来的链表
        HeroNode temp = head.next;
        HeroNode next = null;//指向当前节点的下一个节点
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
        while (temp != null){
            next = temp.next;//先暂时保存当前节点的下一个节点，因为后面需要使用
            temp.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
            reverseHead.next = temp;
            temp = next;//后移
        }
        //将head . next 指向reverseHead.next ，实现单链表的反转
        head.next = reverseHead.next;
    }

4)从尾到头打印单链表[百度，要求方式1:反向遍历。方式2: Stack栈]

 //方式二：
    //可以利用栈这个数据结构,将各个节点压入到栈中,然后利用栈的先进后出的特点，就实现了逆序打印的效果
    public static void reversePrint(HeroNode head){
        if (head.next == null){
            return;
        }

        Stack<HeroNode> stack = new Stack<>();
        HeroNode temp = head.next;
        while (temp != null){
            stack.push(temp);
            temp = temp.next;
        }

        while (stack.size()>0){
            System.out.println(stack.pop());
        }
    }

5)合并两个有序的单链表，合并之后的链表依然有序[课后练习.]

双向链表

使用带head头的双向链表实现-水浒英雄排行榜

管理单向链表的缺点分析：

1)单向链表， 查找的方向只能是-一个方向，而双向链表可以向前或者向后查找。

2)单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除
链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp,temp是待删除节点的前一
个节点

3)示意图

在这里插入图片描述

4)代码实现

package com.zhao.linkedlist;

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        DoubleLinkedList linkedList = new DoubleLinkedList();
        HeroNode2 heroNode1 = new HeroNode2(1,"宋江","及时雨");
        HeroNode2 heroNode2 = new HeroNode2(2,"晁盖","托塔天王");
        HeroNode2 heroNode3 = new HeroNode2(3,"卢俊义","玉麒麟");
        HeroNode2 heroNode4 = new HeroNode2(4,"林冲","豹子头");
        HeroNode2 heroNode6 = new HeroNode2(5,"林冲","豹子头");
        HeroNode2 heroNode7 = new HeroNode2(6,"林冲","豹子头");
        HeroNode2 heroNode5 = new HeroNode2(4,"公孙胜","入云龙");

        linkedList.addByOrder(heroNode3);
        linkedList.addByOrder(heroNode2);
        linkedList.list();
        linkedList.del(2);
        linkedList.list();


    }
}

//创建一个双向链表的类
class DoubleLinkedList{
    private HeroNode2 head = new HeroNode2(0,"","");

    public HeroNode2 getHead() {
        return head;
    }

    //遍历双向链表的方法
    public void list() {
        //判断链表是否为空
        if (head.next == null) {
            return;
        }
        HeroNode2 temp = head.next;

        while (true){
            if (temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }

    }

    //添加
    public void add(HeroNode2 heroNode){
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode2 temp = head;
        //遍历链表，找到最后
        while (true){
            //找到链表的最后
            if (temp.next == null){
                break;
            }
            //如果没找到最后，将temp后移
            temp = temp.next;
        }

        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
        heroNode.pre = temp;

    }

    //第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    //(如果有这个排名,则添加失败，并给出提示)
    public void addByOrder(HeroNode2 heroNode){
        //因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        //因为单链表，因为我们找的temp是位于添加位置的前一个节点,否则插入不了
        HeroNode2 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){//说明已经存在
                flag = true;
                break;
            }

            temp=temp.next;//后移，遍历当前链表
        }

        //判断flag的值
        if (flag){//不能添加，说明编号存在
            System.out.println("编号为"+heroNode.no+"的英雄已经存在了");

        }else {
            // 为防止出现空指针的情况，需要对temp节点位置进行判断
            // 若双向链表尚未到达尾端，则需要将node节点与其相邻的后面的节点进行连接
            if(temp.next != null) {
                heroNode.next = temp.next;
                temp.next.pre = heroNode;
            }

            // 无论双向链表是否到达尾端，都需要将node节点与其相邻的前面的节点进行连接
            temp.next = heroNode;
            heroNode.pre = temp;

        }
    }


    //修改节点的信息，根据no编号来修改，即no编号不能改
    //1.根据 newHeroNode 的 no 来修改即可
    public void update(HeroNode2 newHeroNode){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }

        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode2 temp = head.next;
        boolean flag = false;//表示是否找到该节点
        while (true){
            if (temp == null){
                break;//已经遍历完链表
            }
            if (temp.no == newHeroNode.no){
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag 判断是否找到要修改的节点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else {
            System.out.println("没有这位英雄");
        }


    }

    //删除节点
    //思路
    //1.head不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2.说明我们在比较时:,是temp.no和需要删除的节点的no比较
    public void del(int no){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        boolean flag = false;//标志是否找到待删除节点时
        while (true){
            if (temp == null){//已经到链表的最后
                break;
            }
            if (temp.no == no){
                //找到的待删除节点
                System.out.println("删除了编号为"+no+"的人");
                flag = true;
                break;
            }
            temp = temp.next; // temp后移，遍历
        }

        if (flag){//找到
            //可以删除
            temp.pre.next = temp.next;
            if (temp.next != null){
                temp.next.pre = temp.pre;
            }
        }else {
            System.out.println("没有这个英雄");
        }
    }
}

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

    public HeroNode2(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}
zhao_to
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
有关链表的面试题
08-28
链表反转是常见的面试题，可以通过迭代或递归实现。迭代法通常涉及三个指针：前驱、当前和后续，每次将当前节点的指针指向前驱，然后更新前驱和当前指针。递归法则通过递归调用函数，将当前节点的后续节点设为其...
常见队列栈链表面试题目及C++实现
李滚滚的博客
04-23 1148
文章目录1 只使用一个数组，实现大小固定的栈和队列2.实现一个特殊的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作。3 如何仅用队列结构实现栈结构？ 如何仅用栈结构实现队列结构？4 猫狗队列 【题目】 宠物、狗和猫的类如下：5. 转圈打印矩阵6 一个正方形N*N，顺时针转90度，如何？ 【咦，不是矩阵转置吗】7 反转单向和双向链表8.“之”字形打印矩阵9 在行列都排好序的矩阵中找...
前端跳槽面试总结之堆栈、队列、链表算法类
浮生离梦的博客
06-14 494
一、堆栈 堆通常是一个可以被看做一棵树的数组对象，堆总是满足下列性质，如下所示： 堆中某个节点的值总是不大于或不小于其父节点的值； 堆总是一棵完全二叉树。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。 堆是在程序运行时，而不是在程序编译时，申请某个大小的内存空间。即动态分配内存，对其访问和对一般内存的访问没有区别。 堆是应用程序在运行的时候请求操作系统分配给自己内存，一般是申请/给予的过程。 堆是指程序运行时申请的动态内存，而栈只是指一种使用
面试题：说一说栈，队列，堆，链表数据结构的存储方式
weixin_50736511的博客
01-18 2048
栈 特点：先进后出 栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈，删除则称为退栈。栈也称为后进先出表。 优点：添加速度快，允许重复； 缺点：只能在一头操作数据，存取其他项很慢 队列 特点：先进后出，就像排队打饭一样 优点：添加速度快，允许重复；和栈一样 缺点：存取其他项都很慢和栈一样 堆 可以被看作一棵树 堆总是满足下列性质：堆中某个节点的值总是不大于或不小于其父节点的值，堆总是一棵完全二叉树。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆 和树的区别：堆是一
算法初级（二）—— 数组、栈、队列、链表相关题目
倩mys的博客
11-13 174
文章目录1、数组与栈和队列之间的转换2、栈与队列的转换3、猫狗队列4、打印旋转90°后的数组5、转圈打印6、单链表和双链表转置7、之字形打印8、在一个行列排好序的数组中找数9、打印两链表公共部分 1、数组与栈和队列之间的转换 将数组转换成栈及其一些基本操作 public static class ArrayStack { private Integer[] arr; ...
用链表和数组实现队列
helloword233的博客
11-15 501
队列的原则是先进先出,主要有offer,poll,peek,isEmpty和size方法. 用链表实现: package Test; class Node{ int var; Node next; Node(int var, Node next){ this.var = var; this.next = next; } Nod...
2021数据结构与算法面试题
08-14
数据结构与算法是计算机科学的基础，对于...以上知识点是数据结构与算法面试题中常见的部分，每个主题下都可能有深入的理论讲解和实践题目，对于准备面试的开发者来说，全面掌握这些内容将大大提升在面试中的竞争力。
其他互联网名企面试笔试题.rar
最新发布
10-18
- 链表：单链表、双链表、循环链表的操作，如反转链表、查找节点等。 - 栈与队列：掌握LIFO（后进先出）和FIFO（先进先出）原理及其应用。 - 树：二叉树、平衡树（AVL、红黑树）、堆（最大堆、最小堆）的性质和...
程序员面试题集锦
10-12
【程序员面试题集锦】是针对IT行业，尤其是Java编程方向的面试者精心整理的一份资源，涵盖了各大公司的面试题目以及数据结构相关的知识点。这份资料旨在帮助应聘者全面准备面试，提升自己的技术水平和应试能力。 一...
数据结构1800题(面试题)
07-06
在这个“数据结构1800题(面试题)”的压缩包中，包含了丰富的面试题，涵盖了数据结构的多个重要方面，如链表、队列、排序以及图等。这些主题对于准备IT行业面试，尤其是软件开发或算法工程师岗位的求职者来说至关重要...
队列（数组实现和链表实现）
beichengll的博客
07-16 1273
1.概念：具有一定操作约束的线性表 2.特点：（1）只能在一端插入（入队），另一端删除（出队）。 （2）.先进先出。 3.存储实现方式：数组、链表。 4.基本操作： 1.数组实现（循环数组）： 注意：（1）、普通的顺序存储的数组用来实现队列时，存在一个问题：当rear（记录队尾的变量）到达maxsize-1时，不能确定队列是否满，因为前面可能
数组与链表实现队列
m0_52061250的博客
05-24 455
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、数组二、链表1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、数组 二、链表 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.
数据结构基础：使用数组和链表实现队列、循环队列
健身变秃，coding变强
09-04 699
其他 如果大家想再次学习一下数据结构，推荐一个数据可视化的数据结构学习网站： https://www.cs.usfca.edu/~galles/visualization/Algorithms.html 一、队列概述 在开始具体的编码之前，我们先聊一下队列。 队列的特点是先进先出FIFO；队列中的数据的处理，就像在车站排队买票一样，先排队的先买到票。 队列常用于计算机操作系统中，它在多用户/多任务环境中尤为重要，因为多个用户或任务可能同时请求同一资源。例如：用户提交到打印机的打印任务由队列控制，保证打印机同
四大基础数据结构：数组、链表、队列和栈
weixin_46585151的博客
03-22 3045
四大基础数据结构：数组、链表、队列和栈1、时间复杂度（大O表示法）2、数组3. 链表合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 1、时间复杂度（大O表示法） 衡量时间复杂度与空间复杂度的计数表示，即 衡量算法时间长与不长、占用内存多与多
数组队列和链表队列
iteye_976的博客
04-20 238
上一周我们学习了用数组来实现队列和用链表来实现队列。数组和链表还有队列的本质都是一样的，都可以理解为用来装东西的容器。 无论使用数组还使用链表来实现队列，都是要实现几个基本的任务，例如添加，取出，删除和插入等。他们的区别在于使用的形式不同。 用数组实现队列的关键是创建两个数组，在实现类的内部，还是使用数组保存装入的队列的对象，每次新加入对象时，则创建一个比原来数组长度大于...
数据结构（数组、链表、栈、队列、树）
Lifelong learning
04-25 1352
数据结构，就是一种程序设计优化的方法论，研究数据的逻辑结构和物理结构以及它们之间相互关系，并对这种结构定义相应的运算，目的是加快程序的执行速度、减少内存占用的空间。
用数组实现链表、栈和队列
⚡
01-26 1154
详解用数组实现单链表、双链表、栈和队列
队列的两种实现方式---数组+链表
hcz666的博客
09-07 528
队列的两种实现方式---数组+链表
数据结构与算法（2）队列、单链表
nswzr的博客
05-26 472
1. 队列 1. 队列概述： （1）队列是一个有序列表，可以用链表或者数组进行实现 （2）遵循先入先出的原则。即：先存入的数据先取出，后存入的数据后取出 （3）示意图 2. 数组模拟队列 （1）队列本身就是有序列表，若使用数组的结构来存储队列的数据，则队列的声明如图所示，其中maxSize是该队列的最大容量 （2）因为队列的输出、输入分别从前后端来处理，因此需要两个变量front和rear分别记录队列前后端下标，front会随着数据输出而改变，rear随着数据输入而改变 （3）当我们将数组存入队列时称为
软件技术基础-栈结构(与“队列”有关文档共38张).pptx
11-13
软件技术基础-栈结构(与“队列”有关文档共38张).pptx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值