三、自己动手实现------------“栈和队列”

最新推荐文章于 2024-08-12 09:04:58 发布
最新推荐文章于 2024-08-12 09:04:58 发布
阅读量319 收藏
点赞数
分类专栏： 数据结构和算法 数据结构和算法（Java语言）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/angel_guoo/article/details/90143905
版权

参考文章：

https://www.cnblogs.com/Java3y/p/8670783.html?utm_source=tuicool&utm_medium=referral     【Java实现】栈和队列就是这么简单

https://blog.csdn.net/u012152619/article/details/41785717      数据结构之栈

 https://blog.csdn.net/u012152619/article/details/41799569    数据结构之队列

https://github.com/liuyubobobo/Play-with-Algorithms  

https://www.cnblogs.com/CherishFX/p/4608880.html            Java实现栈和队列

 

      上面介绍的是一些基本知识，我下面就直接上代码了，如果要了解基本知识请看上面《数据结构之栈》《数据结构之队列》连接，或者自己搜索其他博客文章。

一下内容为代码部分，参考了很多的 波波老师的代码，我是代码搬运工O(∩_∩)O！

 

--------------------------------------------------------♥(ˆ◡ˆԅ)---------------------------------------------------------------

                                                               数组实现栈和队列

--------------------------------------------------------♥(ˆ◡ˆԅ)---------------------------------------------------------------

 

 

栈和队列Java数组实现：

 

栈接口定义：

public interface Stack<E> {

    int getSize();
    boolean isEmpty();
    void push(E e);
    E pop();
    E peek();
}

 

数组的的代码参考 《一、自己动手实现一个------------“动态数组”》

 

栈实现主体部分：

public class ArrayStack<E> implements Stack<E> {

    private Array<E> array;

    public ArrayStack(int capacity){
        array = new Array<>(capacity);
    }

    public ArrayStack(){
        array = new Array<>();
    }

    @Override
    public int getSize(){
        return array.getSize();
    }

    @Override
    public boolean isEmpty(){
        return array.isEmpty();
    }

    public int getCapacity(){
        return array.getCapacity();
    }

    @Override
    public void push(E e){
        array.addLast(e);
    }

    @Override
    public E pop(){
        return array.removeLast();
    }

    @Override
    public E peek(){
        return array.getLast();
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Stack: ");
        res.append('[');
        for(int i = 0 ; i < array.getSize() ; i ++){
            res.append(array.get(i));
            if(i != array.getSize() - 1)
                res.append(", ");
        }
        res.append("] top");
        return res.toString();
    }
}

 

 

 

 

队列接口定义：

public interface Queue<E> {

    int getSize();
    boolean isEmpty();
    void enqueue(E e);
    E dequeue();
    E getFront();
}

 

 

队列中数组的实现    参考 《一、自己动手实现一个------------“动态数组”》

 

 

队列实现主体部分：

public class ArrayQueue<E> implements Queue<E> {

    private Array<E> array;

    public ArrayQueue(int capacity){
        array = new Array<>(capacity);
    }

    public ArrayQueue(){
        array = new Array<>();
    }

    @Override
    public int getSize(){
        return array.getSize();
    }

    @Override
    public boolean isEmpty(){
        return array.isEmpty();
    }

    public int getCapacity(){
        return array.getCapacity();
    }

    @Override
    public void enqueue(E e){
        array.addLast(e);
    }

    @Override
    public E dequeue(){
        return array.removeFirst();
    }

    @Override
    public E getFront(){
        return array.getFirst();
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Queue: ");
        res.append("front [");
        for(int i = 0 ; i < array.getSize() ; i ++){
            res.append(array.get(i));
            if(i != array.getSize() - 1)
                res.append(", ");
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args) {

        ArrayQueue<Integer> queue = new ArrayQueue<>();
        for(int i = 0 ; i < 10 ; i ++){
            queue.enqueue(i);
            System.out.println(queue);
            if(i % 3 == 2){
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}

 

 

循环队列实现主体部分：

public class LoopQueue<E> implements Queue<E> {

    private E[] data;
    private int front, tail;
    private int size;  // 有兴趣的同学，在完成这一章后，可以思考一下：
                       // LoopQueue中不声明size，如何完成所有的逻辑？
                       // 这个问题可能会比大家想象的要难一点点：）

    public LoopQueue(int capacity){
        data = (E[])new Object[capacity + 1];
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue(){
        this(10);
    }

    public int getCapacity(){
        return data.length - 1;
    }

    @Override
    public boolean isEmpty(){
        return front == tail;
    }

    @Override
    public int getSize(){
        return size;
    }

    @Override
    public void enqueue(E e){

        if((tail + 1) % data.length == front)
            resize(getCapacity() * 2);

        data[tail] = e;
        tail = (tail + 1) % data.length;
        size ++;
    }

    @Override
    public E dequeue(){

        if(isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");

        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size --;
        if(size == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);
        return ret;
    }

    @Override
    public E getFront(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        return data[front];
    }

    private void resize(int newCapacity){

        E[] newData = (E[])new Object[newCapacity + 1];
        for(int i = 0 ; i < size ; i ++)
            newData[i] = data[(i + front) % data.length];

        data = newData;
        front = 0;
        tail = size;
    }

    @Override
    public String toString(){

        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size = %d , capacity = %d\n", size, getCapacity()));
        res.append("front [");
        for(int i = front ; i != tail ; i = (i + 1) % data.length){
            res.append(data[i]);
            if((i + 1) % data.length != tail)
                res.append(", ");
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args){

        LoopQueue<Integer> queue = new LoopQueue<>();
        for(int i = 0 ; i < 10 ; i ++){
            queue.enqueue(i);
            System.out.println(queue);

            if(i % 3 == 2){
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}

 

 

--------------------------------------------------------♥(ˆ◡ˆԅ)---------------------------------------------------------------

                                                               链表实现栈和队列

--------------------------------------------------------♥(ˆ◡ˆԅ)---------------------------------------------------------------

 

 

 

Java链表的实现：  具体参考《 二、自己动手实现------------“链表”》

为了下面看着全面些，就将链表实现的代码再放出来一下：

public class LinkedList<E> {

    private class Node{
        public E e;
        public Node next;

        public Node(E e, Node next){
            this.e = e;
            this.next = next;
        }

        public Node(E e){
            this(e, null);
        }

        public Node(){
            this(null, null);
        }

        @Override
        public String toString(){
            return e.toString();
        }
    }

    private Node dummyHead;
    private int size;

    public LinkedList(){
        dummyHead = new Node();
        size = 0;
    }

    // 获取链表中的元素个数
    public int getSize(){
        return size;
    }

    // 返回链表是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 在链表的index(0-based)位置添加新的元素e
    // 在链表中不是一个常用的操作，练习用：）
    public void add(int index, E e){

        if(index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");

        Node prev = dummyHead;
        for(int i = 0 ; i < index ; i ++)
            prev = prev.next;

        prev.next = new Node(e, prev.next);
        size ++;
    }

    // 在链表头添加新的元素e
    public void addFirst(E e){
        add(0, e);
    }

    // 在链表末尾添加新的元素e
    public void addLast(E e){
        add(size, e);
    }

    // 获得链表的第index(0-based)个位置的元素
    // 在链表中不是一个常用的操作，练习用：）
    public E get(int index){

        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed. Illegal index.");

        Node cur = dummyHead.next;
        for(int i = 0 ; i < index ; i ++)
            cur = cur.next;
        return cur.e;
    }

    // 获得链表的第一个元素
    public E getFirst(){
        return get(0);
    }

    // 获得链表的最后一个元素
    public E getLast(){
        return get(size - 1);
    }

    // 修改链表的第index(0-based)个位置的元素为e
    // 在链表中不是一个常用的操作，练习用：）
    public void set(int index, E e){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Update failed. Illegal index.");

        Node cur = dummyHead.next;
        for(int i = 0 ; i < index ; i ++)
            cur = cur.next;
        cur.e = e;
    }

    // 查找链表中是否有元素e
    public boolean contains(E e){
        Node cur = dummyHead.next;
        while(cur != null){
            if(cur.e.equals(e))
                return true;
            cur = cur.next;
        }
        return false;
    }

    // 从链表中删除index(0-based)位置的元素, 返回删除的元素
    // 在链表中不是一个常用的操作，练习用：）
    public E remove(int index){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Remove failed. Index is illegal.");

        // E ret = findNode(index).e; // 两次遍历

        Node prev = dummyHead;
        for(int i = 0 ; i < index ; i ++)
            prev = prev.next;

        Node retNode = prev.next;
        prev.next = retNode.next;
        retNode.next = null;
        size --;

        return retNode.e;
    }

    // 从链表中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    // 从链表中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    // 从链表中删除元素e
    public void removeElement(E e){

        Node prev = dummyHead;
        while(prev.next != null){
            if(prev.next.e.equals(e))
                break;
            prev = prev.next;
        }

        if(prev.next != null){
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size --;
        }
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();

        Node cur = dummyHead.next;
        while(cur != null){
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL");

        return res.toString();
    }
}

 

Java链表实现栈和队列：

 

栈接口定义：

public interface Stack<E> {

    int getSize();
    boolean isEmpty();
    void push(E e);
    E pop();
    E peek();
}

 

栈的主体实现：

public class LinkedListStack<E> implements Stack<E> {

    private LinkedList<E> list;

    public LinkedListStack(){
        list = new LinkedList<>();
    }

    @Override
    public int getSize(){
        return list.getSize();
    }

    @Override
    public boolean isEmpty(){
        return list.isEmpty();
    }

    @Override
    public void push(E e){
        list.addFirst(e);
    }

    @Override
    public E pop(){
        return list.removeFirst();
    }

    @Override
    public E peek(){
        return list.getFirst();
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Stack: top ");
        res.append(list);
        return res.toString();
    }

    public static void main(String[] args) {

        LinkedListStack<Integer> stack = new LinkedListStack<>();

        for(int i = 0 ; i < 5 ; i ++){
            stack.push(i);
            System.out.println(stack);
        }

        stack.pop();
        System.out.println(stack);
    }
}

 

 

 

队列的接口定义：

public interface Queue<E> {

    int getSize();
    boolean isEmpty();
    void enqueue(E e);
    E dequeue();
    E getFront();
}

 

队列实现的主体部分：

public class LinkedListQueue<E> implements Queue<E> {

    private class Node{
        public E e;
        public Node next;

        public Node(E e, Node next){
            this.e = e;
            this.next = next;
        }

        public Node(E e){
            this(e, null);
        }

        public Node(){
            this(null, null);
        }

        @Override
        public String toString(){
            return e.toString();
        }
    }

    private Node head, tail;
    private int size;

    public LinkedListQueue(){
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public int getSize(){
        return size;
    }

    @Override
    public boolean isEmpty(){
        return size == 0;
    }

    @Override
    public void enqueue(E e){
        if(tail == null){
            tail = new Node(e);
            head = tail;
        }
        else{
            tail.next = new Node(e);
            tail = tail.next;
        }
        size ++;
    }

    @Override
    public E dequeue(){
        if(isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");

        Node retNode = head;
        head = head.next;
        retNode.next = null;
        if(head == null)
            tail = null;
        size --;
        return retNode.e;
    }

    @Override
    public E getFront(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        return head.e;
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Queue: front ");

        Node cur = head;
        while(cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL tail");
        return res.toString();
    }

    public static void main(String[] args){

        LinkedListQueue<Integer> queue = new LinkedListQueue<>();
        for(int i = 0 ; i < 10 ; i ++){
            queue.enqueue(i);
            System.out.println(queue);

            if(i % 3 == 2){
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}

 

 

 

循环队列的实现主体部分：

public class LoopQueue<E> implements Queue<E> {

    private E[] data;
    private int front, tail;
    private int size;  // 有兴趣的同学，在完成这一章后，可以思考一下：
    // LoopQueue中不声明size，如何完成所有的逻辑？
    // 这个问题可能会比大家想象的要难一点点：）

    public LoopQueue(int capacity){
        data = (E[])new Object[capacity + 1];
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue(){
        this(10);
    }

    public int getCapacity(){
        return data.length - 1;
    }

    @Override
    public boolean isEmpty(){
        return front == tail;
    }

    @Override
    public int getSize(){
        return size;
    
    }
	
	@Override
    public void enqueue(E e){

        if((tail + 1) % data.length == front)
            resize(getCapacity() * 2);

        data[tail] = e;
        tail = (tail + 1) % data.length;
        size ++;
    }

    @Override
    public E dequeue(){

        if(isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");

        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size --;
		//  getCapacity()/4  是为了防止复杂度震荡
        if(size == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);
        return ret;
    }

    @Override
    public E getFront(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        return data[front];
    }

    private void resize(int newCapacity){

        E[] newData = (E[])new Object[newCapacity + 1];
        for(int i = 0 ; i < size ; i ++)
            newData[i] = data[(i + front) % data.length];

        data = newData;
        front = 0;
        tail = size;
    }

    @Override
    public String toString(){

        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size = %d , capacity = %d\n", size, getCapacity()));
        res.append("front [");
        for(int i = front ; i != tail ; i = (i + 1) % data.length){
            res.append(data[i]);
            if((i + 1) % data.length != tail)
                res.append(", ");
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args){

        LoopQueue<Integer> queue = new LoopQueue<>(5);
        for(int i = 0 ; i < 10 ; i ++){
            queue.enqueue(i);
            System.out.println(queue);

            if(i % 3 == 2){
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}

 

 

 

 

 

 

 

 

 

 

 

Gordon_run
关注
专栏目录
Java：自己实现栈和队列
weixin_43939602的博客
03-09 193
一、什么是栈，什么是队列？ 栈：栈的特点是后进先出，也就是从哪边进从哪边出（就像装在罐子里的糖果，最后装进去的，最先被取出来） 队列：队的特点是先进先出，也就是从哪边进，从另一边出（就像我们排队买饭一样，先排队的人先买到饭） 二、自己实现栈 核心操作：入栈push(把元素放到栈里面)，出栈pop(把最后进来的元素删掉)，取栈顶元素peek（获取到最后一个进来的元素的结果） 2.1 使用顺序表实现 尾插尾删即可（不建议头插头删，由于顺序表是基于数组实现的，如果头插头删，可能会存在大量的挪动元素，效
自己实现一个栈和队列
ARSCCC的博客
05-26 182
文章目录1. 栈2. 队列3. 双端队列4. 循环队列5. 循环双端队列 1. 栈 在这里实现的栈都是基于之前自己实现的ArrayList以及链表，所以说通篇下来代码量比较的少，实际上JDK也是根据已有的数据结构来实现栈的，当然JDK需要考虑的方面肯定比我们考虑的要多很多，至于JDK对栈的具体实现方式在之后的源码分析之中会讲解到； 栈是一种特殊的线性表，它只允许我们在一端进行操作，所以说我们先加进去的元素会比后加进去的元素要更晚的出栈，也就是栈结构先进后出的特点；往栈里面添加元素的操作通常被称为入栈，
【Java数据结构】手动实现——栈 和 队列
DerrickWestbrook的博客
11-24 697
【Java数据结构】手动实现——栈 和 队列栈（Stack）概念实现队列（Queue）概念实现双端队列概念Java中的栈和队列 栈（Stack） 概念 栈： 一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈： 栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈： 栈的删除操作叫做出栈。出数据在栈顶。 实现 利用顺序表实现，即使用尾插 + 尾删的方.
栈和队列的手动实现，以及栈和队列的互相实现
ETpgmer的博客
11-28 148
```java 在这里插入代码片
lua 去除小数点有效数字后面的0_自己动手实现Lua：虚拟机、编译器、标准库（二）——二进制chunk格式...
weixin_39535283的博客
12-04 188
该系列是笔者在学习张秀宏编写的《自己动手实现Lua：虚拟机、编译器、标准库》过程中的笔记总结本章需要的目录结构和编译环境：$ cd $LUAGO/go/ $ cp -r ch01/ ch02 $ mkdir ch02/src/luago/binchunk $ export GOPATH=$PWD/ch02 $ mkdir $LUAGO/lua/ch02Lua的二进制文件chunk跟Java的cla...
Open-DSA：针对各种数据结构和算法的已编译指南（代码）
02-27
它不仅提供了理论知识，还包含实际的C++代码实现，使得学习者可以更加直观地理解和应用这些概念。 一、数据结构 数据结构是组织和存储数据的方式，它对算法的设计和效率有着深远的影响。Open-DSA涵盖了以下主要...
RT-Thread学习笔记总结.tar.gz
07-08
4. 消息队列：线程间通信的一种机制，线程可以发送消息到队列，接收方线程则可以从队列中取出消息。 5. 事件标志组：线程通过设置或清除事件标志来通知其他线程，实现异步通信。 二、RT-Thread功能特性 1. 小巧轻便...
CH6_c常用算法程序集－徐士良著_
10-02
3. 数据结构：可能涉及到链表、栈、队列、树和图等基本数据结构的实现和操作。理解这些数据结构的特性对于编写高效代码至关重要。 4. 动态规划：动态规划是一种解决最优化问题的方法，通过将问题分解为子问题来求解...
【RT-Thread作品秀】基于物联网云平台的智能监测-电路方案
04-19
SAL套接字抽象层:该组件实现了对不同网络协议栈或网络实现接口的抽象，并对上层提供一组标准的API接口，方便网络应用的开发与稳定性。 软件包部分: cJSON:C语言实现的极简的解析 JSON 格式的软件包。 Onenet:RT-...
Data-Stuctures:该存储库包含用C解决的一系列问题
03-30
C语言中可以使用数组或链表来实现栈。 4. **队列**：队列是一种先进先出（FIFO）的数据结构，适用于任务调度、缓冲区管理等。C语言中的队列通常用数组或链表实现。 5. **树**：包括二叉树、平衡树（如AVL树和红黑...
luago-book：《自己动手实现Lua》随书源代码
01-31
《自己动手实现Lua》源代码 :open_book:试读（ ， ） :heart_suit_selector:购买（ ， ， ） :bug: :headphone:加入读者交流群（qq：311942068） :desktop_computer: 相关文章
自己动手实现LUA 虚拟机、编译器和标准库 xmind笔记 和代码学习
草帽boy的博客
02-02 1128
目前代码刷到第十章 https://github.com/qiaojinxia/GoLuaStudy
自己动手实现Lua在windows下的环境搭建
周航的专栏
11-30 646
《自己动手实现lua：虚拟机、编译器和标准库》作者书友QQ群 311942068 注意要保证工具版本与书中一致 lua Lua在Windows下的安装、配置、运行 https://blog.csdn.net/ChinarCSDN/article/details/78667262 现在重启后，输入luac53 -v 就能看到了效果了 起别名 打开cmd doskey lua=lua53 doskey...
推荐项目：自己动手实现Lua - 深入理解Lua的奥秘
最新发布
gitblog_00669的博客
08-12 365
???? 推荐项目：自己动手实现Lua - 深入理解Lua的奥秘 luago-book《自己动手实现Lua》随书源代码项目地址:https://gitcode.com/gh_mirrors/lu/luago-book 1. 项目介绍 ???? 自己动手实现Lua 是一本深入讲解如何从零开始构建一个Lua解释器的技术书籍。通过本书及其配套的GitHub项目,作者不仅详细解析了Lua的核心原理和技术细节,还提...
OpenResty使用Lua大全（十二）实战： 动手实现一个网关框架
秃了也弱了
03-20 1556
统一入口；安全：黑名单、权限身份认证；限流：实现微服务访问流量计算，基于流量计算分析进行限流，可以定义多种限流规则；缓存：数据缓存；日志：记录日志；监控：记录请求响应数据，api耗时分析，性能监控；重试：异常重试；熔断：降级。安装依赖1）OpenResty: 版本应在1.9.7.3+需要编译OpenResty时添加2）lor框架3）MySQL数据库名：orange安装mysql数据库执行相应的版本的数据库脚本。
【java中间件】自己动手实现一个属于自己的mydubbo
wssjdysf1的专栏
03-11 187
https://blog.csdn.net/xc1158840657/article/details/82429385
Lua设计与实现--虚拟机篇
蛰伏--当你不够强大时，就不要放弃努力
12-05 4219
///////////////////////////////////////////////////////////////// 本篇文章是Lua设计与实现专栏的第三篇，主要结合了《Lua设计与实现》书中的第五章(虚拟机)，以及lua5.3源码进行一些总结，由于原书中主要是基于lua5.1进行书写的，所以可能会有跟书中列举代码不一致的地方，不过大体上是保持一致的。 同时，本文虚拟机的概念和类型划分的内容主要参考了这篇blog的，里面讲的挺详细的。 虚拟机基本概念 虚拟机指借助软件系统对物理机器..
Lua的设计与实现——基础数据类型（Lua中的数据类型）
田螺姑娘的博客
05-11 789
Lua的设计与实现——基础数据类型（Lua中的数据类型） 出自书籍：李创.Lua设计与实现[M].北京.人民邮电出版社.2017:186.   在这一部分中，探讨Lua中的基础数据结构。Lua内部采用一种通用的基础数据结构来表示数据类型。Lua语言及其精简，只有字符串和表两种最基本的数据结构。然而，精简并不代表简陋，在这些基础数据结构的实现中，处处可以看到设计者为了性能和可扩展性（这是Lua从一开始就坚持的目标）所做的努力。   Lua是一门动态类型的脚本语言，这意味着同一个变量可以在不同时刻指向不
构建Lua解释器Part1：虚拟机的基础--Lua基本数据结构、栈和基于栈的C函数调用的设计与实现
Shanks
02-15 708
以下内容转载自http://manistein.club/post/program/let-us-build-a-lua-interpreter/%E6%9E%84%E5%BB%BAlua%E8%A7%A3%E9%87%8A%E5%99%A8part1/ 前言 从本篇开始，我们正式进入到Lua解释器的开发阶段（这是一个遵循Lua5.3标准的项目）。本篇并不直接接入到设计和实现语法分析器和词法分析器的阶段，而是先设计和实现Lua虚拟机的基础数据结构（包括Lua最基本的数据结构，如基本数据...
南邮2012-2020数据结构考研真题解析
- 线性表：顺序表、链表、栈、队列等数据结构的特点、实现和应用。 - 树和二叉树：树的定义、性质、遍历算法、二叉树的建立、遍历和二叉搜索树等。 - 图：图的表示方法、图的遍历算法（深度优先搜索和广度优先搜索）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值