Java使用跳转结构实现队列和栈流程详解

更新时间：2023年04月13日 08:28:58 作者：ziop-三月

这篇文章主要介绍了Java使用跳转结构实现队列和栈流程，连续结构和跳转结构是数据结构中常见的两种基本数据结构，而我们本次的主角栈和队列都既可以使用使用跳转结构实现也可以使用连续结构实现

导读

在数据结构当中所有的数据结构都是由连续数据结构或者跳转数据结构单独或者拼接做成。

连续结构和跳转结构是数据结构中常见的两种基本数据结构，而我们本次的主角栈和队列都既可以使用使用跳转结构实现也可以使用连续结构实现。

本文主要是介绍了如何通过跳转结构实现栈和队列，在实现栈和队列之后并使用对数器对写出的栈和队列进行测试。

队列

跳转结构结点

public static class Node<T> {
    public T value;
    public Node<T> next;
    public Node(T value) {
        this.value = value;
    }
    @Override
    public String toString() {
        ArrayList<T> nums = new ArrayList<>();
        Node<T> node = this;
        while (node != null) {
            nums.add(node.value);
            node = node.next;
        }
        return nums.toString();
    }
}

实现队列

public static class MyQueue<T> {
    private Node<T> head;
    private Node<T> tail;
    private int size;
    public MyQueue() {
        head = null;
        tail = null;
        size = 0;
    }
    // 插入一个元素
    public void offer(T t) {
        Node<T> node = new Node<>(t);
        if (head == null) {
            head = node;
        } else {
            tail.next = node;
        }
        tail = node;
        size++;
    }
    // 弹出一个元素
    public T poll() {
        T ans = null;
        if (head != null) {
            ans = head.value;
            head = head.next;
            size--;
        }
        if (head == null) {
            tail = null;
        }
        return ans;
    }
//  查看队首元素
    public T peek() {
        T ans = null;
        if (head != null) {
            ans = head.value;
        }
        return ans;
    }
    //检查 队列是否为空
    public Boolean isEmpty() {
        return size == 0;
    }
    // 查看队列的长度
    public int size() {
        return size;
    }
}

测试队列

public static void main(String[] args) {
    MyQueue<Integer> myQueue = new MyQueue<>();
    Queue<Integer> test = new LinkedList<>();
    int testTime = 5000000;
    int maxValue = 200000000;
    System.out.println("测试开始！");
    for (int i = 0; i < testTime; i++) {
        if (myQueue.isEmpty() != test.isEmpty()) {
            System.out.println("Oops!");
        }
        if (myQueue.size() != test.size()) {
            System.out.println("Oops!");
        }
        double decide = Math.random();
        if (decide < 0.33) {
            int num = (int) (Math.random() * maxValue);
            myQueue.offer(num);
            test.offer(num);
        } else if (decide < 0.66) {
            if (!myQueue.isEmpty()) {
                Integer num1 = myQueue.poll();
                Integer num2 = test.poll();
                if (!num1.equals(num2)) {
                    System.out.println("Oops!");
                }
            }
        } else {
            if (!myQueue.isEmpty()) {
                Integer num1 = myQueue.peek();
                Integer num2 = test.peek();
                if (!num1.equals(num2)) {
                    System.out.println("Oops!");
                }
            }
        }
    }
    if (myQueue.size() != test.size()) {
        System.out.println("Oops!");
    }
    while (!myQueue.isEmpty()) {
        Integer num1 = myQueue.poll();
        Integer num2 = test.poll();
        if (!num1.equals(num2)) {
            System.out.println("Oops!");
        }
    }
    System.out.println("测试结束！");
}

栈

实现栈

public static class MyStack<T> {
    private Node<T> head;
    private int size;
    public MyStack() {
        head = null;
        size = 0;
    }
    //检查 栈是否为空
    public Boolean isEmpty() {
        return size == 0;
    }
    // 查看栈的长度
    public int size() {
        return size;
    }
    // 插入一个元素
    public void push(T t) {
        Node<T> node = new Node<>(t);
        if (head != null) {
            node.next = head;
        }
        head = node;
        size++;
    }
    public T pop() {
        T ans = null;
        if (head != null) {
            ans = head.value;
            head = head.next;
            size--;
        }
        return ans;
    }
    //  查看栈顶元素
    public T peek() {
        T ans = null;
        if (head != null) {
            ans = head.value;
        }
        return ans;
    }
}

测试代码

public static void main(String[] args) {
    MyStack<Integer> myStack = new MyStack<>();
    Stack<Integer> test = new Stack<>();
    int testTime = 5000000;
    int maxValue = 200000000;
    System.out.println("测试开始！");
    for (int i = 0; i < testTime; i++) {
        if (myStack.isEmpty() != test.isEmpty()) {
            System.out.println("Oops!");
        }
        if (myStack.size() != test.size()) {
            System.out.println("Oops!");
        }
        double decide = Math.random();
        if (decide < 0.33) {
            int num = (int) (Math.random() * maxValue);
            myStack.push(num);
            test.push(num);
        } else if (decide < 0.66) {
            if (!myStack.isEmpty()) {
                int num1 = myStack.pop();
                int num2 = test.pop();
                if (num1 != num2) {
                    System.out.println("Oops!");
                }
            }
        } else {
            if (!myStack.isEmpty()) {
                int num1 = myStack.peek();
                int num2 = test.peek();
                if (num1 != num2) {
                    System.out.println("Oops!");
                }
            }
        }
    }
    if (myStack.size() != test.size()) {
        System.out.println("Oops!");
    }
    while (!myStack.isEmpty()) {
        int num1 = myStack.pop();
        int num2 = test.pop();
        if (num1 != num2) {
            System.out.println("Oops!");
        }
    }
    System.out.println("测试结束！");
}

到此这篇关于Java使用跳转结构实现队列和栈流程详解的文章就介绍到这了,更多相关Java跳转结构实现队列和栈内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

java贪吃蛇游戏实现代码
这篇文章主要为大家详细介绍了java贪吃蛇游戏实现代码，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2020-10-10
XML Web 服务 Eclipse实现sun-jaxws.xml文件的方法
在sun-jaxws.xml文件,可以配置endpoint、handler-chain等内容,在这个文件中配置的内容会覆盖在Java代码中使用注解属性配置的的内容,本文给大家介绍的非常详细,感兴趣的朋友一起看看吧
2023-11-11
如何安装java的运行环境IDEA
这篇文章主要介绍了如何安装java的运行环境IDEA,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-07-07
Spring Boot使用Allatori代码混淆的方法
这篇文章主要介绍了Spring Boot使用Allatori代码混淆的方法,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2018-03-03
深入解析堆排序的算法思想及Java代码的实现演示
堆排序基于二叉堆结构即完全二叉树,可利用最大堆和最小堆的组建方式来进行排序,这里就来深入解析堆排序的算法思想及Java代码的实现演示
2016-06-06
详解Spring Boot集成MyBatis（注解方式）
本篇文章主要介绍了详解Spring Boot集成MyBatis（注解方式），小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-05-05
如何解决mybatis查询结果接收不同的问题
这篇文章主要介绍了如何解决mybatis查询结果接收不同的问题,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-09-09
详解spring boot集成RabbitMQ
RabbitMQ作为AMQP的代表性产品，在项目中大量使用。结合现在主流的spring boot，极大简化了开发过程中所涉及到的消息通信问题。
2017-03-03
Sentinel 整合SpringCloud的详细教程
Spring Cloud Alibaba Sentinel 是阿里巴巴提供的，致力于提供微服务一站式解决方案，这篇文章主要介绍了Sentinel 之整合SpringCloud的相关知识,需要的朋友可以参考下
2021-10-10
SpringBoot 配置提示功能(超详细)
这篇文章主要介绍了SpringBoot 配置提示功能，本文给大家介绍的超详细，通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
2019-10-10