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

最新推荐文章于 2023-04-12 09:45:23 发布
最新推荐文章于 2023-04-12 09:45:23 发布
阅读量226 收藏
点赞数
分类专栏： 数据结构和算法 数据结构和算法（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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
luago-book：《自己动手实现Lua》随书源代码
01-31
《自己动手实现Lua》源代码 :open_book:试读（ ， ） :heart_suit_selector:购买（ ， ， ） :bug: :headphone:加入读者交流群（qq：311942068） :desktop_computer: 相关文章
【RT-Thread作品秀】基于物联网云平台的智能监测-电路方案
04-19
SAL套接字抽象层:该组件实现了对不同网络协议栈或网络实现接口的抽象，并对上层提供一组标准的API接口，方便网络应用的开发与稳定性。 软件包部分: cJSON:C语言实现的极简的解析 JSON 格式的软件包。 Onenet:RT-...
Lua的设计与实现——基础数据类型（Lua中的数据类型）
田螺姑娘的博客
05-11 721
Lua的设计与实现——基础数据类型（Lua中的数据类型） 出自书籍：李创.Lua设计与实现[M].北京.人民邮电出版社.2017:186.   在这一部分中，探讨Lua中的基础数据结构。Lua内部采用一种通用的基础数据结构来表示数据类型。Lua语言及其精简，只有字符串和表两种最基本的数据结构。然而，精简并不代表简陋，在这些基础数据结构的实现中，处处可以看到设计者为了性能和可扩展性（这是Lua从一开始就坚持的目标）所做的努力。   Lua是一门动态类型的脚本语言，这意味着同一个变量可以在不同时刻指向不
构建Lua解释器Part1：虚拟机的基础--Lua基本数据结构、栈和基于栈的C函数调用的设计与实现
Shanks
02-15 628
以下内容转载自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最基本的数据结构，如基本数据...
探索Lua5.2内部实现:编译系统(1) 概述
热门推荐
原林的专栏
01-18 2万+
原文 Lua是一个轻量级高效率的语言。这种轻量级和高效率不仅体现在它本身虚拟机的运行效率上，而且也体现在他整个的编译系统的实现上。因为绝大多数的lua脚本需要运行期动态的加载编译，如果编译过程本身非常耗时，或者占用很多的内存，也同样会影响到整体的运行效率，使你感觉这个语言不够“动态”。正是因为编译系统实现的非常出色，我们在实际使用lua时基本感觉不到这个过程的存在。 要实现一个Lua的编译
Lua设计与实现--虚拟机篇
蛰伏--当你不够强大时，就不要放弃努力
12-05 3971
///////////////////////////////////////////////////////////////// 本篇文章是Lua设计与实现专栏的第三篇，主要结合了《Lua设计与实现》书中的第五章(虚拟机)，以及lua5.3源码进行一些总结，由于原书中主要是基于lua5.1进行书写的，所以可能会有跟书中列举代码不一致的地方，不过大体上是保持一致的。 同时，本文虚拟机的概念和类型划分的内容主要参考了这篇blog的，里面讲的挺详细的。 虚拟机基本概念 虚拟机指借助软件系统对物理机器..
windows驱动开发技术详解-part2
07-06
力求让读者通过亲自动手实验，掌握各类Windows驱动 程序的开发技巧，学习尽可能多的Windows底层知识。 　本书适用于中、高级系统程序员，同时也可用做高校计算机专业操作系统实验课的补充教材。 原创经典，威盛...
Windows驱动开发技术详解的光盘-part1
07-06
力求让读者通过亲自动手实验，掌握各类Windows驱动程序的开发技巧，学习尽可能多的Windows底层知识。 　本书适用于中、高级系统程序员，同时也可用做高校计算机专业操作系统实验课的补充教材。 原创经典，威盛一线...
siftjava源码-MaoDataStructures:Arrays(数组)、Stacks(栈)、Queues(队列)、LinkedList
06-18
Arrays(数组)、Stacks(栈)、Queues(队列)、LinkedList(链表)、Recursion(递归思想)、BinarySearchTree(二分搜索树)、Set(集合)、Map(映射)、Heap(堆)、PriorityQueue(优先队列)、SegmentTree(线段树)、Trie(字典树)...
leetcode有效期-LeetCode-practice:LeetCode练习代码、数据结构，以及使用swift的常用排序算法
07-07
初步的计划是先实现一些基础的也是应用最多的排序算法，然后在刷leetcode的过程中遇到数据结构，动手实现一些，数据结构是单独实现，没有相互嵌套和复用，主要是给自己做一个笔记，所有代码都是使用swift实现。...
Lua语言实现游戏动作
记录 IT 领域经验与见解的博客
04-12 2210
Lua语言是一种轻量级的脚本语言，它可以用来实现游戏动作，包括角色行走、攻击、技能释放等。在使用Lua语言实现游戏动作时，需要了解游戏引擎提供的API，设计良好的代码结构，并不断地调试代码。在函数内部，可以使用游戏引擎提供的API来实现角色的攻击。在游戏开发中，实现游戏动作是非常重要的。1.了解游戏引擎API：在使用Lua语言实现游戏动作时，需要了解游戏引擎提供的API，这样才能够正确地实现游戏动作。2.设计良好的代码结构：在实现游戏动作时，需要设计良好的代码结构，以方便代码的维护和扩展。
Lua语言学习与实践书籍推荐(10本)
记录 IT 领域经验与见解的博客
03-02 1046
Lua语言学习与实践书籍推荐
Java：自己实现栈和队列
weixin_43939602的博客
03-09 160
一、什么是栈，什么是队列？ 栈：栈的特点是后进先出，也就是从哪边进从哪边出（就像装在罐子里的糖果，最后装进去的，最先被取出来） 队列：队的特点是先进先出，也就是从哪边进，从另一边出（就像我们排队买饭一样，先排队的人先买到饭） 二、自己实现栈 核心操作：入栈push(把元素放到栈里面)，出栈pop(把最后进来的元素删掉)，取栈顶元素peek（获取到最后一个进来的元素的结果） 2.1 使用顺序表实现 尾插尾删即可（不建议头插头删，由于顺序表是基于数组实现的，如果头插头删，可能会存在大量的挪动元素，效
自己动手实现Lua在windows下的环境搭建
周航的专栏
11-30 606
《自己动手实现lua：虚拟机、编译器和标准库》作者书友QQ群 311942068 注意要保证工具版本与书中一致 lua Lua在Windows下的安装、配置、运行 https://blog.csdn.net/ChinarCSDN/article/details/78667262 现在重启后，输入luac53 -v 就能看到了效果了 起别名 打开cmd doskey lua=lua53 doskey...
lua 去除小数点有效数字后面的0_自己动手实现Lua：虚拟机、编译器、标准库（二）——二进制chunk格式...
weixin_39535283的博客
12-04 159
该系列是笔者在学习张秀宏编写的《自己动手实现Lua：虚拟机、编译器、标准库》过程中的笔记总结本章需要的目录结构和编译环境：$ cd $LUAGO/go/ $ cp -r ch01/ ch02 $ mkdir ch02/src/luago/binchunk $ export GOPATH=$PWD/ch02 $ mkdir $LUAGO/lua/ch02Lua的二进制文件chunk跟Java的cla...
自己动手实现LUA 虚拟机、编译器和标准库 xmind笔记 和代码学习
草帽boy的博客
02-02 1033
目前代码刷到第十章 https://github.com/qiaojinxia/GoLuaStudy
自己动手实现Lua调试器
xyjikl
11-20 3572
这段时间在qnode项目中新增了一个叫ldb的子项目，它的作用是使用C语言实现了一个lua调试器，后面将会在qnode中嵌入对调试lua脚本的支持。 先来简单提一下ldb的用法，在ldb目录的子目录test中，有一个main.c文件，其中使用ldb库提供的API实现对lua脚本的调试演示： #include #include "ldb.h" ldb_t *ldb; static in
自己实现一个栈(Stack)和队列(Queue)
Stay hungry, Stay foolish
07-17 1886
需求实现一个栈(Stack)和队列(Queue). 栈：后进先出 队列：先进先出
教学计划编制C语言数据结构
最新发布
05-23
- 演示如何使用数组实现一些基本的数据结构，如栈、队列、链表等 - 练习编写一些数组相关的程序，如冒泡排序、二分查找等 第三周： - 讲解指针的基本概念、指针与数组的关系、指针的算术运算等 - 演示如何使用指针...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值