数据结构和算法java实现——队列、链表

最新推荐文章于 2023-04-29 22:25:24 发布
最新推荐文章于 2023-04-29 22:25:24 发布
阅读量254 收藏 1
点赞数
分类专栏： 数据结构和算法 文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42506939/article/details/119947782
版权

数据结构和算法java实现——队列

一、队列

1 基本介绍

  • 队列是一个有序列表，可以用数组或是链表来实现。
  • 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出

2 数组实现队列

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

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

在这里插入图片描述

  1. 当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析
    将尾指针往后移：rear+1 , 当front == rear 【空】
    若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear所指的数组元素中，否则无法存入数据。 rear == maxSize - 1[队列满]

代码实现：

// 数组实现队列
public class ArrayQueue {
    private  int maxSize;//数组的最大容量
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//存储数据的数组，模拟队列

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

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

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

    // 添加数据
    public void addQueue(int n){
        // 判断队列是否满
        if (isFull()){
            System.out.println("队列已满，不能加入数据");
            return;
        }
        rear++;//让rear后移
        arr[rear] = n;
    }

    // 获取队列数据
    public int getQueue(){
        // 判断队列是否为空
        if (isEmpty()){
            throw new RuntimeException("队列空，不能获取数据");
        }
        front++;//后移
        return arr[front];
    }

    // 遍历
    public void showQueue(){
        if (isEmpty()){
            System.out.println("队列为空，没有数据~");
            return;
        }
        for (int i = 0; i <arr.length ; i++) {
            System.out.printf("arr[%d]=%d\n", i, arr[i]);
        }
    }

    // 显示队列的头数据， 注意不是取出数据
    public int headQueue() {
        // 判断
        if (isEmpty()) {
            throw new RuntimeException("队列空的，没有数据~~");
        }
        return arr[front + 1];
    }
}

3 数组实现循环队列

思路如下:

  1. front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
    front 的初始值 = 0
  2. rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
    rear 的初始值 = 0
  3. 当队列满时，条件是 (rear + 1) % maxSize == front 【满】
  4. 对队列为空的条件， rear == front 空
  5. 当我们这样分析， 队列中有效的数据的个数 (rear + maxSize - front) % maxSize // rear = 1 front = 0
  6. 我们就可以在原来的队列上修改得到，一个环形队列

在这里插入图片描述

public class CircleArrayQueue {
    private int maxSize; // 表示数组的最大容量
    //front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
    //front 的初始值 = 0
    private int front;
    //rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
    //rear 的初始值 = 0
    private int rear; // 队列尾
    private int[] arr; // 该数据用于存放数据, 模拟队列

    public CircleArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];

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

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

    // 添加数据
    public void addQueue(int n){
        // 判断队列是否满
        if (isFull()){
            System.out.println("队列已满，不能加入数据");
            return;
        }
        arr[rear] = n;
        //让rear后移
        rear = (rear+1)%maxSize;
    }

    // 获取队列数据
    public int getQueue(){
        // 判断队列是否为空
        if (isEmpty()){
            throw new RuntimeException("队列空，不能获取数据");
        }
        // 这里需要分析出 front是指向队列的第一个元素
        // 1. 先把 front 对应的值保留到一个临时变量
        // 2. 将 front 后移, 考虑取模
        // 3. 将临时保存的变量返回
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

    // 遍历
    public void showQueue(){
        if (isEmpty()){
            System.out.println("队列为空，没有数据~");
            return;
        }
        // 思路：从front开始遍历，遍历多少个元素
        for (int i = front; i <front+size() ; i++) {
            System.out.printf("arr[%d]=%d\n", i%maxSize, arr[i%maxSize]);
        }
    }

    public int size(){
        return (rear+maxSize-front)%maxSize;
    }

    // 显示队列的头数据， 注意不是取出数据
    public int headQueue() {
        // 判断
        if (isEmpty()) {
            throw new RuntimeException("队列空的，没有数据~~");
        }
        return arr[front];
    }
}

二、 链表

1 概述

  • 链表是以节点的方式来存储,是链式存储
  • 每个节点包含 data 域， next 域：指向下一个节点.
  • 如图：发现链表的各个节点不一定是连续存储.
  • 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定
    在这里插入图片描述

2 单项链表实现

在这里插入图片描述定义一个节点类：

//定义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 + '\'' +
                '}';
    }
}

具体增删改查遍历代码实现：

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

    public HeroNode getHead() {
        return head;
    }


    //增
    //思路，当不考虑编号顺序时
    //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){
                break;
            }
            if (temp.next.no >heroNode.no){//位置找到，就在temp的后面插入
                break;
            }else if (temp.next.no == heroNode.no) {//说明希望添加的heroNode的编号已然存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }
        //判断flag 的值
        if(flag) { //不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", 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.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

    // 删
    //删除节点
    //思路
    //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后移，遍历
        }
        //判断flag
        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 = temp.next;
        }
    }

}

3 双向链表

  • 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
  • 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp,temp是待删除节点的前一个节点(认真体会).

分析 双向链表的遍历，添加，修改，删除的操作思路===》代码实现

  1. 遍历 方和 单链表一样，只是可以向前，也可以向后查找
  2. 添加 (默认添加到双向链表的最后)
    (1) 先找到双向链表的最后这个节点
    (2) temp.next = newHeroNode
    (3) newHeroNode.pre = temp;
  3. 修改 思路和 原来的单向链表一样.
  4. 删除
    (1) 因为是双向链表，因此，我们可以实现自我删除某个节点
    (2) 直接找到要删除的这个节点，比如temp
    (3) temp.pre.next = temp.next
    (4) temp.next.pre = temp.pre;

具体代码实现：

// 双向链表
public class DoubleLinkedList {
    //先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode2 head = new HeroNode2(0, "", "");

    //增
    public void add(HeroNode2 heroNode){
        //因为head节点不能动，因此我们需要一个辅助遍历 temp
        HeroNode2 temp = head;
        //遍历链表，找到最后
        while (true){
            // 找到链表最后
            if (temp.next== null){
                break;
            }
            // 如果没有找到最后，将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //形成一个双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    // 删
    //删除节点
    //思路
    // 1 对于双向链表，我们可以直接找到要删除的这个节点
    // 2 找到后，自我删除即可
    public void del(int no) {
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }

        HeroNode2 temp = head.next;
        boolean flag = false; // 标志是否找到待删除节点的
        while(true) {
            if(temp.next == null) { //已经到链表的最后
                break;
            }
            if(temp.no == no) {
                //找到的待删除节点
                flag = true;
                break;
            }
            temp = temp.next; //temp后移，遍历
        }
        //判断flag
        if(flag) { //找到
            //可以删除
            temp.pre.next = temp.next;
            if (temp.next !=  null){
                temp.next.pre = temp.pre;
            }
        }else {
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }


    // 改
    //修改节点的信息, 根据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.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

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

        boolean flag = false;// flag标志添加的编号是否存在，默认为false
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.no >heroNode.no){//位置找到，就在temp的后面插入
                break;
            }else if (temp.no == heroNode.no) {//说明希望添加的heroNode的编号已然存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }
        //判断flag 的值
        if(flag) { //不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
        } else {
            //插入到链表中, temp的后面
            if (temp.next != null){
                temp.next.pre = heroNode;
            }
            heroNode.next = temp.next;
            temp.next = heroNode;
            heroNode.pre = temp;
        }
    }

    // 遍历
    public void list(){
        // 判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode2 temp = head.next;
        while(true) {
            //判断是否到链表最后
            if(temp == null) {
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp后移， 一定小心
            temp = temp.next;
        }
    }

}
// 定义HeroNode2 ， 每个HeroNode 对象就是一个节点
class HeroNode2 {
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next; // 指向下一个节点, 默认为null
    public HeroNode2 pre; // 指向前一个节点, 默认为null
    // 构造器

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

    // 为了显示方法，我们重新toString
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    }

}

4 循环列表（Josephu(约瑟夫、约瑟夫环) 问题

构建一个单向的环形链表思路

  1. 先创建第一个节点, 让 first 指向该节点，并形成环形
  2. 后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可.

遍历环形链表

  1. 先让一个辅助指针(变量) curBoy，指向first节点
  2. 然后通过一个while循环遍历 该环形链表即可 curBoy.next == first 结束
public class Josepfu {

    public static void main(String[] args) {
        // 测试一把看看构建环形链表，和遍历是否ok
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(10);// 加入5个小孩节点
        circleSingleLinkedList.showBoy();
        //测试一把小孩出圈是否正确
        circleSingleLinkedList.countBoy(1, 2, 8);

    }

}
// 创建一个环形的单向链表
class CircleSingleLinkedList {
    // 创建一个first节点,当前没有编号
    private Boy first = null;

    // 添加小孩节点，构建成一个环形的链表
    public void addBoy(int nums) {
        // nums 做一个数据校验
        if (nums < 1) {
            System.out.println("nums的值不正确");
            return;
        }
        Boy curBoy = null; // 辅助指针，帮助构建环形链表
        // 使用for来创建我们的环形链表
        for (int i = 1; i <= nums; i++) {
            // 根据编号，创建小孩节点
            Boy boy = new Boy(i);
            // 如果是第一个小孩
            if (i == 1) {
                first = boy;
                first.setNext(first); // 构成环
                curBoy = first; // 让curBoy指向第一个小孩
            } else {
                curBoy.setNext(boy);//
                boy.setNext(first);//
                curBoy = boy;
            }
        }
    }

    // 遍历当前的环形链表
    public void showBoy() {
        // 判断链表是否为空
        if (first == null) {
            System.out.println("没有任何小孩~~");
            return;
        }
        // 因为first不能动，因此我们仍然使用一个辅助指针完成遍历
        Boy curBoy = first;
        while (true) {
            System.out.printf("小孩的编号 %d \n", curBoy.getNo());
            if (curBoy.getNext() == first) {// 说明已经遍历完毕
                break;
            }
            curBoy = curBoy.getNext(); // curBoy后移
        }
    }

    // 根据用户的输入，计算出小孩出圈的顺序
    /**
     *
     * @param startNo
     *            表示从第几个小孩开始数数
     * @param countNum
     *            表示数几下
     * @param nums
     *            表示最初有多少小孩在圈中
     */
    public void countBoy(int startNo, int countNum, int nums) {

        // 先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数输入有误， 请重新输入");
            return;
        }
        // 创建要给辅助指针,帮助完成小孩出圈
        Boy helper = first;
        // 需求创建一个辅助指针(变量) helper , 事先应该指向环形链表的最后这个节点
        while (true) {
            if (helper.getNext() == first) { // 说明helper指向最后小孩节点
                break;
            }
            helper = helper.getNext();
        }
        //小孩报数前，先让 first 和  helper 移动 k - 1次
        for(int j = 0; j < startNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        //当小孩报数时，让first 和 helper 指针同时 的移动  m  - 1 次, 然后出圈
        //这里是一个循环操作，知道圈中只有一个节点
        while(true) {
            if(helper == first) { //说明圈中只有一个节点
                break;
            }
            //让 first 和 helper 指针同时 的移动 countNum - 1
            for(int j = 0; j < countNum - 1; j++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            //这时first指向的节点，就是要出圈的小孩节点
            System.out.printf("小孩%d出圈\n", first.getNo());
            //这时将first指向的小孩节点出圈
            first = first.getNext();
            helper.setNext(first); //

        }
        System.out.printf("最后留在圈中的小孩编号%d \n", first.getNo());

    }
}



// 创建一个Boy类，表示一个节点
class Boy {
    private int no;// 编号
    private Boy next; // 指向下一个节点,默认null

    public Boy(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }

}
鲑鱼683
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构&算法——Java.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： ...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
java数组/链表实现栈和队列
woai3364的博客
02-07 458
​ 栈（stack) 是限定仅在表尾进行插入或删除操作和线性表（只有一端口能进出数据），对栈来说表尾和表头有特殊含义，表尾被称为栈顶，表头被称为栈底，没有元素的空表称为空栈，元素数量达到栈的容量称为满栈，数据添加到栈中叫入栈、压栈，数据从栈中删除叫出栈、弹栈，由于栈元素特殊添加和删除的规则，所以栈的元素会先进后出的现象，简称为LIFO（Last in first out）。入栈的思路就是先将栈顶指针向上移一位，再直接赋值，前提需判断该栈是否满，当然栈满了，是不允许再进栈的。链表——实现队列：（双链表）
Java用链表实现队列
daBai_Zzz的博客
01-08 1811
/** * 链表实现队列 */ public class LinkedQueue { class Node{ int val; Node next; public Node(int val){this.val=val;} public Node(int val,Node next){this.val=val;this.next=next;} } // 队头指针 Node front; // 队尾指针
java语言实现链队列
初心不忘、始终方得
05-13 2355
使用java语言实现链队列
【java】队列和链表
loveliveluo的博客
07-07 358
初学数据结构
数据结构与算法（Java版）数据结构知识点
m0_62110645的博客
04-03 445
数组：一种线性数据结构，可以存储一组相同类型的元素。Java中数组是固定长度的，可以使用下标访问数组中的元素。链表：一种线性数据结构，由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。Java中可以使用LinkedList实现单向链表，或者使用自定义类实现双向链表。栈：一种后进先出（LIFO）的数据结构，可以使用数组或链表实现。Java中可以使用Stack类实现栈。队列：一种先进先出（FIFO）的数据结构，可以使用数组或链表实现。
算法和数据结构——左程云.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
Java数据结构和算法
09-29
（1）数据结构与算法概念解析 （2）数据结构之数组 （3）数据结构之栈 （4）数据结构之队列 （5）数据结构之链表 （6）数据结构之二叉树 （7）数据结构之霍夫曼树 （8）数据结构之红黑树（一）——基础分析 ...
程序员代码面试指南——IT名企算法和数据结构题目最优解.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： ...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
【Java数据结构】顺序表、队列、栈、链表、哈希表
m0_73976305的博客
04-29 557
链表在随机访问数据的时候，需要通过遍历来完成，而顺序表则利用数组的特性可以直接访问得到，当我们读取数据多于插入删除操作的时候，使用顺序表会更好；顺序表在进行插入删除操作的时候，因为需要移动后续元素，会很浪费时间，链表则不需要，只需要修改结点的指向就行了。所以在进行频繁的插入删除操作的时候，使用链表必然是更好的。
数组、链表、栈、队列、树
lercent的博客
11-25 997
数组、链表、栈、队列、树
java 链表、栈、队列、树的实现
colonel的博客
12-16 2949
最近无意中翻到一本书，闲来无事写几行代码，实现几种常用的数据结构，以备后查。 一、线性表（链表） 1、节点定义 /**链表节点定义 * @author colonel * */ class Node { public int data; Node next=null; public Node(int data){ this.data=data; } }2、链表操作类
链表实现队列（java实现）
LC_HYQ的博客
02-21 1559
package shuju_arguments; /** * * 使用链表数据结构来实现队列 * **/ public class queue { //对头指针 private node&lt;Integer&gt; first; //队尾指针 private node&lt;Integer&gt; last; //队列元素的数量 private int num; //队头出...
java 用链表实现队列,Java用链表实现队列
weixin_36292762的博客
03-20 291
队列--先入先出栈---后入先出链表实现队列和栈。首先我们需要构建一个链表。链表有哪几要素？1、链表本身的value2、链表的next指针，next指针指的还是同样类型的值。下边看代码public class Element{private T value;//链表值private Elementnext;//指针public void setNext(Elementnext) {this.nex...
Java 使用链表来实现队列功能
Difffate的技术随笔
08-28 2380
/** * 链表元素定义 * Create by zxb on 2017/8/27 */ public class Element { private Element next; private T value; public Element getNext() { return next; } public void setN
java使用链表实现队列
ljxbbss的博客
09-30 4207
队列使用Java进行链表实现，在网上找到了一张图，很好，借鉴一下 设置两个结点node，front指向队首元素，rear指向队尾； 上代码： public class LinkedQueue { Node front;//队头指针，指向队头节点 Node rail;//队尾指针，指向队尾节点 int size = 0;//记录队列长度 //
java 用单链表实现队列
小蓝的博客
07-28 2119
public class LinkQueue { class Node { private T data;//数据域 private Node next;//引用域 public Node() { this.data=null; this.next=null; } public Node(T data) { this.data=data;
Java中队列的实现(2)-使用单向链表以及实现
daguairen的博客
10-06 2481
队列(Queue)：是另一种被限制过的线性表，它是固定一端来插入数据元素，另一端只删除元素，也就是说队列中的元素移动是固定的，就像超市收银台一样，一边是进的，一边是出的，而且是先进入的首先获得服务的。 队列是一个特殊的线性表，它只允许在表的前端(front)进行删除操作，只允许在表的后端(rear)进行插入数据。进行插入操作的端称之为队尾，进行删除操作的端称之为队头。对于一个队列来说
Java链表实现队列
zab635590867的博客
01-27 615
问题：用链表实现一个先进先出的队列 分析： 1、链表实现，必须有一个节点能够装数据和下一个节点的指针（引用） 2、队列必须要有队首、队尾指针和记录当前队列大小的整型数 3、入队：往队尾加，队尾的下一个指针指向新元素，随后移动队尾指针指向新元素 4、出队：取出队首数据，移动队首指针指向队首的下一个元素 5、边界问题考虑 实现 1、节点类 /** * 队列结点 * * @author zab * @date 2021-01-27 11:13 */ public class Nod.
java 数据结构 队列 栈 链表 线性表 排序的知识点
11-28
队列（Queue）是一种先进先出（First-In, First-Out, FIFO）的数据结构。在队列中，只允许在一端进行插入操作，而在另一端进行删除操作。...理解这些知识点可以帮助我们更好地理解和应用Java的数据结构和算法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值