（七）栈的三种实现

最新推荐文章于 2024-07-08 13:20:28 发布
最新推荐文章于 2024-07-08 13:20:28 发布
阅读量135 收藏
点赞数
文章标签： java 数据结构与算法
原文链接：http://www.cnblogs.com/datamining-bio/p/9642830.html
版权

目标

  • 使用链表、数组或向量实现ADT栈
  • 对不同的实现方式及其性能进行对比

 

6.1 链式实现

　　ADT栈中每个操作push、pop、peek都会涉及栈顶，使用链式，将头结点指向的第一个元素作为栈顶，链的最后一个元素作为栈底。

类的框架

　　有一个数据域topNode，为节点链的头引用，构造时默认为null，实现类包含Node类，每个节点都为Node类的实例对象。

　　链式实现ADT栈的类框架

public class LinkedStack<T> implements StackInterface<T> {
　　private Node topNode;
　　public LinkedStack() {
　　　　topNode = null;
　　} // end default constructor
　　@Override
　　public void push(T newEntry) {
　　　　// TODO Auto-generated method stub
　　} // end push
　　@Override
　　public T pop() {
　　　　// TODO Auto-generated method stub
　　　　return null;
　　} // end pop
　　@Override
　　public T peek() {
　　　　// TODO Auto-generated method stub
　　　　return null;
　　} // end peek
　　@Override
　　public boolean isEmpty() {
　　　　// TODO Auto-generated method stub
　　　　return false;
　　} // end isEmpty
　　@Override
　　public void clear() {
　　　　// TODO Auto-generated method stub
　　} // end clear
　　private class Node{
　　　　private T data;       // Entry in stack
　　　　private Node next;    // Link to next node
　　　　public Node(T data, Node next) {
　　　　　　super();
　　　　　　this.data = data;
　　　　　　this.next = next;
　　　　} // end constructor
　　　　public T getData() {
　　　　　　return data;
　　　　} // end getData
　　　　public void setData(T data) {
　　　　　　this.data = data;
　　　　} // end setData
　　　　public Node getNextNode() {
　　　　　　return next;
　　　　} // end getNextNode
　　　　public void setNextNode(Node next) {
　　　　　　this.next = next;
　　　　} // end setNextNode
　　} // end Node
} // end LinkedStack

在栈顶添加  O(1)

　　即在链表中添加一个项到链表头

/**
 * Adds a new entry to the top of this stack.
 * @param newEntry: An object to be added to the stack.
 */
@Override    // O(1)
public void push(T newEntry) {
　　topNode = new Node(newEntry, topNode);
} // end push

获取栈顶 O(1)

　　返回头结点指向的节点的数据域，栈为空抛出异常

/**
 * Retrieves this stack's top entry.
 * @return: The object at the top of the stack.
 * @throws: EmptyStackException if the stack is empty.
 */
@Override
public T peek() {
　　if (isEmpty()) {
　　　　throw new EmptyStackException();
　　}
　　else {
　　　　return topNode.getData();
　　} // end if
} // end peek
/**
 * Detects whether this stack is empty.
 * @return: True if the stack is empty.
 */
@Override
public boolean isEmpty() {
　　return topNode == null;
} // end isEmpty

　　将异常抽出为私有方法

public T peek() {
　　checkStactEmpty();
　　return topNode.getData();
} // end peek
private void checkStactEmpty() {
　　if (isEmpty()) {
　　　　throw new EmptyStackException();
　　} // end if
} // end checkStackEmpty

删除栈顶  O(1) 

　　即删除头结点指向的第一个节点，处理栈为空的异常

/**
 * Romoves and returns this stack's top entry.
 * @return: The object at the top of the stack.
 * @throws: EmptyStackException if the stack is empty before the operation.
 */
@Override
public T pop() {
　　T top = peek();  // Might throw EmptyStackException
　　assert topNode != null;
　　topNode = topNode.getNextNode();
　　return top;
} // end pop

其他方法

public boolean isEmpty() {
　　return topNode == null;
} // end isEmpty
public void clear() {
　　topNode = null;
} // end clear

总：

import java.util.EmptyStackException;

/**
 * A class of stacks whose entries are stored in a chain of nodes.
 * @author Administrator
 *
 * @param <T>
 */
public class LinkedStack<T> implements StackInterface<T> {
    private Node topNode;
    //private int numberOfEntries;
    
    public LinkedStack() {
        topNode = null;
    } // end default constructor

    /**
     * Adds a new entry to the top of this stack.
     * @param newEntry: An object to be added to the stack.
     */
    @Override    // O(1)
    public void push(T newEntry) {
        topNode = new Node(newEntry, topNode);
        //numberOfEntries++;
    } // end push

    /**
     * Romoves and returns this stack's top entry.
     * @return: The object at the top of the stack.
     * @throws: EmptyStackException if the stack is empty before the operation.
     */
    @Override
    public T pop() {
        T top = peek();  // Might throw EmptyStackException
        assert topNode != null;
        topNode = topNode.getNextNode();
        //numberOfEntries--;
        return top;
    } // end pop

    /**
     * Retrieves this stack's top entry.
     * @return: The object at the top of the stack.
     * @throws: EmptyStackException if the stack is empty.
     */
    @Override
    public T peek() {
        checkStactEmpty();
        return topNode.getData();    
    } // end peek

    private void checkStactEmpty() {
        if (isEmpty()) {
            throw new EmptyStackException();
        } // end if
    } // end checkStackEmpty
    
    /**
     * Detects whether this stack is empty.
     * @return: True if the stack is empty.
     */
    @Override
    public boolean isEmpty() {
        //return numberOfEntries == 0;
        return topNode == null;
    } // end isEmpty

    /*
    public int getCurrentSize() {
        return numberOfEntries;
    }
    */
    
    /**
     * Removes all entries from this stack.
     */
    @Override
    public void clear() {
        topNode = null;
    } // end clear
    
    private class Node{
        private T data;       // Entry in stack
        private Node next;    // Link to next node
        public Node(T data, Node next) {
            super();
            this.data = data;
            this.next = next;
        } // end constructor
        public T getData() {
            return data;
        } // end getData
        public void setData(T data) {
            this.data = data;
        } // end setData
        public Node getNextNode() {
            return next;
        } // end getNextNode
        public void setNextNode(Node next) {
            this.next = next;
        } // end setNextNode
        
    } // end Node
} // end LinkedStack
View Code

6.2 基于数组的实现 

　　数组第一个位置为栈底，最后一个为栈顶

类的框架

public class ArrayStack<T> implements StackInterface<T> {
　　private T[] stack;      // Array of stack entries
　　private int topIndex;   // Index of top entry
　　private boolean initialized = false;
　　private static final int DEFAULT_CAPACITY = 50;
　　private static final int MAX_CAPACITY = 10000;
　　public ArrayStack() {
　　　　this(DEFAULT_CAPACITY);
　　} // end default constructor
　　public ArrayStack(int initialCapacity) {
　　　　checkCapacity(initialCapacity);
　　　　@SuppressWarnings("unchecked")
　　　　T[] tempStack = (T[])new Object[initialCapacity];
　　　　stack = tempStack;
　　　　topIndex = -1;
　　　　initialized = true;
　　} // end ArrayStack
　　private void checkCapacity(int capacity) {
　　　　if (capacity > MAX_CAPACITY) {
　　　　　　throw new IllegalStateException("Attempt to create a stack whose "
　　　　　　　　　　　　　　　　　　　　+ "capacity exceeds allowed maximum.");
　　　　} // end if
　　} // end checkCapacity
　　@Override
　　public void push(T newEntry) {
　　　　// TODO Auto-generated method stub
　　}
　　@Override
　　public T pop() {
　　　　// TODO Auto-generated method stub
　　　　return null;
　　}
　　@Override
　　public T peek() {
　　　　// TODO Auto-generated method stub
　　　　return null;
　　}
　　@Override
　　public boolean isEmpty() {
　　　　// TODO Auto-generated method stub
　　return false;
　　}
　　@Override
　　public void clear() {
　　　　// TODO Auto-generated method stub
　　}
} // end ArrayStack

在栈顶添加

　　不需要改变数组大小时，为O(1)，改变数组大小的操作是O(n)的，所以数组满时，push为O(n)。下一次又为O(1)，公平起见，所有push操作应均摊偶尔的数组调整改变的开销。即将数组倍增的开销分摊到栈的所有入栈操作上。除非必须多次地调整数组大小，否则每次push几乎都是O(1)的。

 

public void push(T newEntry) {
　　checkInitialization();
　　ensureCapacity();
　　stack[topIndex + 1] = newEntry;
　　topIndex++;
} // end push
private void ensureCapacity() {
　　if (topIndex == stack.length - 1) {  // If array is full, double its size
　　　　int newLength = stack.length * 2;
　　　　checkCapacity(newLength);
　　　　stack = Arrays.copyOf(stack, newLength);
　　} // end if
} // end ensureCapacity
// Throws an exception if this ovject is not initialized.
private void checkInitialization() {
　　if(!initialized) {
　　　　throw new SecurityException("ArrayStack object is not initialized properly.");
　　}
} // end checkInitialized
private void checkCapacity(int capacity) {
　　if (capacity > MAX_CAPACITY) {
　　　　throw new IllegalStateException("Attempt to create a stack whose "
　　　　　　　　　　　　　　　　　　+ "capacity exceeds allowed maximum.");
　　} // end if
} // end checkCapacity

获取栈顶  O(1)

　　注意栈空抛出异常

public T peek() {
　　checkInitialization();
　　checkStackEmpty();
　　return stack[topIndex];
} // end peek
public boolean isEmpty() {
　　return topIndex < 0;
} // isEmpty
private void checkStackEmpty() {
　　if (isEmpty()) {
　　　　throw new EmptyStackException();
　　} // end if
} // end checkStackEmpty

删除栈顶  O(1)

　　注意栈空抛异常

public T pop() {
　　T result = peek();
　　stack[topIndex] = null;
　　topIndex--;
　　return result;
} // end pop

isEmpty和clear方法

public boolean isEmpty() {
　　return topIndex < 0;
} // isEmpty
public void clear() {
　　while (!isEmpty()) {
　　　　pop();
　　} // end while
} // end clear

数组实现：

涉及到数组数据的方法均需要检查初始化是否成功；

peek，pop注意检查栈是否为空，为空则抛异常。

import java.util.Arrays;

public class ArrayStack<T> implements StackInterface<T> {
    private T[] stack;      // Array of stack entries
    private int topIndex;   // Index of top entry
    private boolean initialized = false;
    private static final int DEFAULT_CAPACITY = 50;
    private static final int MAX_CAPACITY = 10000;
    
    public ArrayStack() {
        this(DEFAULT_CAPACITY);
    } // end default constructor
    
    public ArrayStack(int initialCapacity) {
        checkCapacity(initialCapacity);
        @SuppressWarnings("unchecked")
        T[] tempStack = (T[])new Object[initialCapacity];
        stack = tempStack;
        topIndex = -1;
        initialized = true;
    } // end ArrayStack

    private void checkCapacity(int capacity) {
        if (capacity > MAX_CAPACITY) {
            throw new IllegalStateException("Attempt to create a stack whose "
                    + "capacity exceeds allowed maximum.");
        } // end if
    } // end checkCapacity

    /**
     * Adds a new entry to the top of this stack.
     * @param newEntry: An object to be added to the stack.
     */
    @Override
    public void push(T newEntry) {
        checkInitialization();
        ensureCapacity();
        stack[topIndex + 1] = newEntry;
        topIndex++;
    } // end push

    
    private void ensureCapacity() {
        if (topIndex == stack.length - 1) {  // If array is full, double its size
            int newLength = stack.length * 2;
            checkCapacity(newLength);
            stack = Arrays.copyOf(stack, newLength);
        } // end if
    } // end ensureCapacity

    /**
     * Romoves and returns this stack's top entry.
     * @return: The object at the top of the stack.
     * @throws: EmptyStackException if the stack is empty before the operation.
     */
    @Override
    public T pop() {
        T result = peek();
        stack[topIndex] = null;
        topIndex--;
        return result;
    } // end pop

    /**
     * Retrieves this stack's top entry.
     * @return: The object at the top of the stack.
     * @throws: EmptyStackException if the stack is empty.
     */
    @Override
    public T peek() {
        checkInitialization();
        checkStackEmpty();
        return stack[topIndex];
    } // end peek

    @Override
    public boolean isEmpty() {
        return topIndex < 0;
    } // isEmpty
    
    private void checkStackEmpty() {
        if (isEmpty()) {
            throw new EmptyStackException();
        } // end if
    } // end checkStackEmpty

    // Throws an exception if this ovject is not initialized.
    private void checkInitialization() {
        if(!initialized) {
            throw new SecurityException("ArrayStack object is not initialized properly.");
        }
    } // end checkInitialized
    
    /**
     * Removes all entries from this stack.
     */
    @Override
    public void clear() {
        while (!isEmpty()) {
            pop();
        } // end while
    } // end clear
} // end ArrayStack
View Code

6.3 基于向量的实现

　　让栈按需增大的一种办法是将元素保存在可变大小的数组中，另一种办法是使用向量（vector）替代数组。向量是一个对象，其行为类似于高级数组。与数组中的项一样向量中的项也有下标，且从0开始。与向量不同的是，向量有设置或访问项的方法。可以创建一个指定大小的向量，而且它的大小按需增长，实现细节对客户隐藏。

6.3.1 Java类库：类Vector

　　Java类库中包含类Vector，其实例（称为向量）的行为类似于一个可变大小的数组，下面是实现ADT栈时会用到的Vector的构造方法和方法：

public Vector()

创建一个空向量或类似于数组的容器，初始大小为10.当向量需要扩展容量时，容量倍增。

public Vector(int initialCapacity)

创建一个带指定初始容量的空向量。当向量需要扩展容量时，容量倍增。

public boolean add(T newEntry)

将新元素添加到向量的末尾。数组扩增也是通过数组复制得到的。

public T remove(int index)

删除向量中指定下标的项并返回，后续操作和ArrayList相同，将后面的数据向前复制。

public void clear()

删除向量中的所有项。将所有项设为null。

public T lastElement()

返回向量中的最后一项。

public boolean isEmpty()

如果向量为空则返回真。

public int size()

返回向量中当前的元素个数。

　　注：Java类库中的类Vector在Java.util包中。向量类似于可变大小的数组，其元素有从0开始的下标。可以使用类中的方法来处理向量。

6.3.2 使用向量实现ADT栈

　　使用向量保存栈的元素，类似于使用数组保存栈的元素，但更容易。让向量的第一个元素指向栈底元素。所以，向量看起来与之前的数组一样。不需要维护栈顶元素的下标，可以从向量的大小推出这个下标，向量大小很容易得到。

　　注：如果使用向量实现栈，则向量的首元应该指向栈底元素。而向量最后的占用位置指向栈顶元素。

类的框架

　　实现栈的类首先要声明一个向量作为数据域，并在构造方法中分配向量。

import java.util.Vector;
/**
 * A class of stacks whose entries are stored in a vector.
 * @author Administrator
 *
 */
public class VectorStack<T> implements StackInterface<T> {
　　private Vector<T> stack;    // Last element is the top entry in stack
　　private boolean initialized = false;
　　private static final int DEFAULT_CAPACITY = 50;
　　private static final int MAX_CAPACITY = 10000;
　　public VectorStack() {
　　　　this(DEFAULT_CAPACITY);
　　} // end default constructor
　　public VectorStack(int initialCapacity) {
　　　　checkCapacity(initialCapacity);
　　　　stack = new Vector<>(initialCapacity);   // Size double as need
　　　　initialized = true;
　　} // end constructor
　　private void checkCapacity(int capacity) {
　　　　if (capacity > MAX_CAPACITY) {
　　　　　　throw new IllegalStateException("Attempt to create a stack whose "
　　　　　　　　　　　　　　　　　　　　　　+ "capacity exceeds allowed maximum.");
　　　　} // end if
　　} // end checkCapacity
} // end VectorStack

在栈顶添加

　　使用类Vector的方法add，可以将元素添加到向量尾，即栈顶。

public void push(T newEntry) {
　　checkInitialization();
　　stack.add(newEntry);
} // end push

获取栈顶

　　使用类Vector的方法lastElement，可以获取栈顶元素

 

public T peek() {
　　checkInitialization();
　　checkStackEmpty();
　　return stack.lastElement();
} // end peek

　删除栈顶

　使用Vector的方法remove，可以删除栈顶元素。方法的参数是向量最后一个元素的下标，因为那个元素是栈顶。下标是向量当前大小stack.size()减1.

public T pop() {
　　checkInitialization();
　　checkStackEmpty();
　　return stack.remove(stack.size() - 1);
} // end pop

类的其他方法

public boolean isEmpty() {
　　return stack.isEmpty();
} // end isEmpty
public void clear() {
　　stack.clear();
} // end clear

　　注：写VectorStack比写基于数组实现的代码容易，因为调用了Vector的方法，而运行时间要多于ArrayStack方法的运行时间。但是，多出的这些时间常常微不足道。

小结

链式实现中栈的操作都是O(1)的；

调整数组大小可避免栈满时不能容纳新元素。但是数组中往往含有未用的位置；

基于数组的实现中，栈操作是O(1)的。数组满时push为O(n),分摊所有入栈则为O(1)；

因为Vector的实现是基于动态可变大小的数组的，所以基于向量实现的栈的性能类似于基于数组实现的性能。

 

转载于:https://www.cnblogs.com/datamining-bio/p/9642830.html

badiu_30394251
关注
如何用两个队列实现一个栈及其性能分析
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-31 878
在计算机科学中，栈（Stack）和队列（Queue）是两种常见的数据结构，它们各自有着独特的操作方式和应用场景。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。在某些特定场景下，我们可能需要使用一种数据结构来实现另一种数据结构的功能。本文将详细探讨如何使用两个队列来实现一个栈，并分析相关栈操作的运行时间。
栈的向量实现(数制转换问题)
05-05
栈的向量实现(数制转换问题) 十进制转换为八进制
DS03栈
Jerry&Crj的博客
04-21 230
文章目录三、栈1.定义2.应用场景3. 图解4.例子1-数组模拟栈4.1 代码 三、栈 1.定义 栈的英文为(stack) 栈是一个先入后出(FILO-First In Last Out)的有序列表。 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先
栈的实现
SENLINZM的专栏
07-28 683
使用链表的方式来实现栈
栈的实现——java
weixin_30352645的博客
10-07 74
和C++一样，JDK包中也提供了"栈"的实现，它就是集合框架中的Stack类。关于Stack类的原理，在"Java 集合系列07之 Stack详细介绍(源码解析)和使用示例"中，已经详细介绍过了。本部分给出2种Java实现Java实现一：数组实现的栈，能存储任意类型的数据。Java实现二：Java的 Collection集合 中自带的"栈"(stack)的示例。 1. Java实...
Java栈的实现
hjy的博客
03-19 897
Java栈的实现 栈 是限制仅在表的一端进行插入和删除运算的线性表。 插入或删除的一端为栈顶，另一端称为栈底当表中没有元素时为空栈栈为后进先出的线性表，又称LIFO表 栈没有查找操作，查看非栈顶元素的唯一方式是反复从栈中删除元素，直到想要的元素位于栈顶。 栈的操作： push(newEntry)：将新元素插入栈顶pop()：删除栈顶元素并返回值peek：返回栈顶元素但
SS7协议栈、七号信令协议栈（MTP2、MTP3、TUP、ISUP）
04-08
SS7协议栈，全称Signalling System No.7，是通信行业中用于交换网络的一种关键协议栈，主要用于控制和管理通信网络中的呼叫建立、维护和拆除等过程。它由多个层次的协议组成，主要包括MTP（Message Transfer Part）...
C++用两个栈实现一个队列（面试官的小结）
08-26
"C++用两个栈实现一个队列" 知识点概述： 本文主要介绍了使用两个栈实现一个队列的方法，通过面试官的小结，详细介绍了相关知识点。文章中通过示例代码对知识点进行了详细的介绍，对学习或使用C++的人具有一定的...
Java定义栈结构，并实现入栈、出栈操作完整示例
08-25
在 Java 中，栈是一种先进后出的数据结构，即后入栈的元素最先被取出。栈可以使用数组或链表实现，本文使用 ArrayList 实现栈结构。 栈结构的定义包括以下几个部分： * 入栈（push）：将元素添加到栈顶 * 出栈...
TCPIP协议栈的设计与实现【中文】
11-03
TCP/IP协议栈基于OSI七层模型的理念，但简化为四层结构：应用层、传输层、网络层和数据链路层。应用层包括HTTP、FTP等协议，传输层有TCP（传输控制协议）和UDP（用户数据报协议），网络层包含IP（网际协议），而...
java中栈的实现
头发茂密的假程序猿
01-14 318
先说结论 java中的栈官方推荐使用Deque（发音：呆克，不是迪克哈哈） 类图查看 用idea打开Deque接口，发现483行有栈的两个经典方法push，pop。并且注明了是Stack methods 左侧有个标有绿色的大写I的图片，点开可以查看它的所有实现类 可以看到上图中有我们熟悉的LinkedList，所以如果我们想使用栈这种数据结构，只需要使用LinkedList就可以了，切记使用多态时要用Deque类型接收 Deque stack = new LinkedList(); 一开始是刷leec
栈的两种实现方式
weixin_43900407的博客
01-28 362
1、栈的链表实现 通过链表前端的插入来实现push，通过删除表前端元素来实现pop。
栈的实现详解
最新发布
m0_68142120的博客
07-08 436
/StackType是存储元素的类型int Top;}ST,*pS;a：指针，用来存储数据Top：栈顶元素在a中的位置capacity：a能容纳的元素个数。
六、栈的实现两种方式
liuchuangjin的博客
05-26 955
前言：栈的特点：先进先出，只在栈顶进行操作。栈低密封，不进行操作，栈的实现有两种方式，通过对线性表实现进行复用。安全性高。 实现栈的方式：                          第一种：以顺序结构的方式实现：将顺序表的队尾作为栈顶                          第二种：以链式结构的方式实现：将链式表的队头作为栈顶 第一种实现方式(顺序结构)：
四、栈的向量实现和队列的数组实现
weixin_44824326的博客
01-07 306
一、栈和队列的区别 1.栈先进后出 2.队列先进先出 二、栈的向量实现代码 用到的vector函数： clear、reserve、push_back、empty、back、pop_back #include <vector> template<class T,int capacity = 30> class Stack{ private: vector<T> p...
栈实现
weixin_41631293的博客
02-20 265
邓俊辉数据结构 栈实现 学堂在线 栈教学视频 环境：DEV C++5.4.0。有课程资源但是无法运行，于是自己结合视频敲了一边，函数名称尽量与视频中统一，有细微的不同。 栈可以由向量和LIST实现。这里实现了栈的入栈、出栈、查询是否为空、查询顶部函数。 **经典应用 ：**括号匹配、进展转换 向量代码 列表实现 1.向量实现栈 这里采用的是聚合方式 #include "vector.hpp" te...
栈的简单实现及应用
南猿北者博客
11-10 2443
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。入栈：栈的插入操作叫做进栈/压栈/入栈；（从栈顶插入数据）出栈：栈的删除操作叫做出栈；（也是从栈顶删除数据）做个简单的比喻：我们的栈就相当于一个弹夹，入栈操作就相当向弹夹之中压入子弹；出栈操作就相当将弹夹里面的子弹取出来；而这个压入子弹和取出子弹都只有一个口；这个口就是栈顶，出入数据都从栈顶进行；
一个数组实现两个栈(共享栈)
Hanani_Jia的博客
04-12 2208
一个数组实现两个栈，既然是一个数组变成两个栈，首先得把你的数组分成两部分， 这是一个十个元素的数组，有几种方法把他分成两部分呢？这么分！ 还是这么分！ 或者这么分！言归正传，其实分成两部分还是有两种分发的，第一种就是我上边画的第三种从中间开始分，将你的数组分成两个，分别成为一个栈。但是还有一种分发，是比较不容易想到的，那就是将你的数据的数据进行奇偶分开。  下标是红色的是一个栈，绿色的是另外一个栈...
C语言栈的顺序和链式实现原理及实现代码
三、栈的简单应用 * 使用顺序栈解决简单应用问题，如括号匹配、表达式求值等。 四、链式栈的实现 * 链式栈的定义：typedef struct Node{ DATATYPE data; struct Node* next; } LINKSTACK; * 链式栈的基本运算：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值