stack_stackoverflow - CSDN
stack 订阅
栈(stack)在计算机科学中是限定仅在表尾进行插入或删除操作的线性表。栈是一种数据结构,它按照后进先出的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶,需要读数据的时候从栈顶开始弹出数据。栈是只能在某一端插入和删除的特殊线性表。用桶堆积物品,先堆进来的压在底下,随后一件一件往上堆。取走时,只能从上面一件一件取。读和取都在顶部进行,底部一般是不动的。栈就是一种类似桶堆积物品的数据结构,进行删除和插入的一端称栈顶,另一端称栈底。插入一般称为进栈,删除则称为退栈。 栈也称为后进先出表。 展开全文
栈(stack)在计算机科学中是限定仅在表尾进行插入或删除操作的线性表。栈是一种数据结构,它按照后进先出的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶,需要读数据的时候从栈顶开始弹出数据。栈是只能在某一端插入和删除的特殊线性表。用桶堆积物品,先堆进来的压在底下,随后一件一件往上堆。取走时,只能从上面一件一件取。读和取都在顶部进行,底部一般是不动的。栈就是一种类似桶堆积物品的数据结构,进行删除和插入的一端称栈顶,另一端称栈底。插入一般称为进栈,删除则称为退栈。 栈也称为后进先出表。
信息
性    质
计算机科学中是一种数据结构
解    释
古代用竹木条横排编成车箱的车子
外文名
Stack
中文名
其他意义
姓氏
Stack进栈算法
①若TOP≥n时,则给出溢出信息,作出错处理(进栈前首先检查栈是否已满,满则溢出;不满则作②);②置TOP=TOP+1(栈指针加1,指向进栈地址);③S(TOP)=X,结束(X为新进栈的元素);
收起全文
精华内容
参与话题
  • 本文转载于http://blog.csdn.net/gscsdlz/article/details/52169463一、简介 stack是一种容器适配器(STL的容器分为顺序容器和关联容器,容器适配器,是对这两类容器进行包装得到的具有更强的约束力... stack通过...

    本文转载于http://blog.csdn.net/gscsdlz/article/details/52169463

    一、简介

           stack是一种容器适配器(STL的容器分为顺序容器和关联容器,容器适配器,是对这两类容器进行包装得到的具有更强的约束力的容器),被设计来用于操作先进后出(FILO)结构的情景,在这种情况下, 元素的插入和删除都只能在容器的尾部进行。

           stack通过容器适配器来实现,是一种将特定的容器类作为其最底层的容器的类,它提供了一些特定的成员函数来访问自己的元素,元素只能在这个特定容器的后面,也就是栈的顶部,进行出栈和入栈操作。

           最底层的容器可以是任意一种标准的容器模板类,或者是一些有明确目的的容器类,他们应该支持以下操作:

    1. empty判断是否为空
    2. size 返回栈的元素个数
    3. back 返回栈顶元素
    4. push_back 入栈
    5. pop_back出栈
           标准的容器类,比如vector,deque,list,满足以上需求。如果没有明确指定需要使用的容器,默认情况下将会使用deque

    二、函数用法示例

    1、构造与析构(C++11版本)

    1. initialize (1)          explicit stack (const container_type& ctnr);  
    2.   
    3. move-initialize (2)     explicit stack (container_type&& ctnr = container_type());  
    4.   
    5. allocator (3)           template <class Alloc> explicit stack (const Alloc& alloc);  
    6.   
    7. init + allocator (4)    template <class Alloc> stack (const container_type& ctnr, const Alloc& alloc);  
    8.   
    9. move-init + allocator (5)  template <class Alloc> stack (container_type&& ctnr, const Alloc& alloc);  
    10.   
    11. copy + allocator (6)    template <class Alloc> stack (const stack& x, const Alloc& alloc);  
    12.   
    13. move + allocator (7)    template <class Alloc> stack (stack&& x, const Alloc& alloc);  
    (1)初始化构造方式
             构造一个内部元素都是ctnr的拷贝的容器适配器

    (2)move-initialization constructor
            构造一个内部元素都是通过移动方式获得ctnr的值的容器适配器

    剩下几个带分配器的我还没有看懂,就不乱说了
    cplusplus的例子:
    1. // constructing stacks  
    2. #include <iostream>       // std::cout  
    3. #include <stack>          // std::stack  
    4. #include <vector>         // std::vector  
    5. #include <deque>          // std::deque  
    6.   
    7. int main ()  
    8. {  
    9.   std::deque<int> mydeque (3,100);          // deque with 3 elements  
    10.   std::vector<int> myvector (2,200);        // vector with 2 elements  
    11.   
    12.   std::stack<int> first;                    // empty stack  
    13.   std::stack<int> second (mydeque);         // stack initialized to copy of deque  
    14.   
    15.   std::stack<int,std::vector<int> > third;  // empty stack using vector  
    16.   std::stack<int,std::vector<int> > fourth (myvector);  
    17.   
    18.   std::cout << "size of first: " << first.size() << '\n';  
    19.   std::cout << "size of second: " << second.size() << '\n';  
    20.   std::cout << "size of third: " << third.size() << '\n';  
    21.   std::cout << "size of fourth: " << fourth.size() << '\n';  
    22.   
    23.   return 0;  
    24. }  


    2、empty()

    返回当前栈是否为空(当它的大小是0的时候),empty()函数并不能清空栈,只是一个返回bool型的const函数

    1.     stack<int>s;  
    2.     s.push(1);  
    3.     s.push(2);  
    4.     cout << s.empty() << endl;   //输出0  

    3、size()

    返回容器中元素的个数,时间复杂度O(1),返回值类型是size_type,也就是unsigned intsize()函数不能改变栈的大小

    例如上面的代码段应该输出 2

    4、top()

    返回栈顶元素的引用。
    由于栈是一种先进后出的结构,所以最顶部的元素就是最后插入栈的元素。
    C++11中会自动根据元素类型返回reference或者是const_reference,对一个空的栈调用top函数,会异常终止,所以应该使用empty()函数提前检查)
    1. stack<int>s;  
    2. s.push(1);  
    3. s.push(2);  
    4. cout << s.top() << endl;    //输出2  
    5. s.top() += 3;               //引用可以作为左值  
    6. cout << s.top() << endl;    //输出5  

    5、push() 和 emplace() (C++11)

    push()函数和emplace()都是在栈这个容器的顶部插入一个新的元素。
    push(),实际上是调用的底层容器的push_back()函数,新元素的值是push函数参数的一个拷贝。
    emplace(),实际上是调用的底层容器的emplace_back()函数,新元素的值是在容器内部就地构造的,不需要移动或者拷贝。
    stackemplace也可以用在普通的基本类型上。
    1. struct Node  
    2. {  
    3.     Node(int x)  
    4.         :x(x){}  
    5.     int x;  
    6. };  
    7.   
    8. int main()  
    9. {  
    10.     stack<Node>s1;  
    11.     s1.emplace(1);  
    12.     s1.push(Node(2));  
    13.   
    14.     stack<int>s2;  
    15.     s2.emplace(1);   //OK  
    16.     return 0;  
    17. }  

    6、pop()

    删除最顶部的元素,使栈的大小减小

    这个被删除的元素,是刚刚插入栈的元素,这个元素和top函数的返回值是一致的。这个函数会调用对象的析构函数(如果有的话),pop()实际上是用过底层容器的pop_back()函数实现的。

    对一个空栈进行pop(),会导致程序异常终止,应该使用empty提前检查

    1. stack<int>s;  
    2. s.push(1);  
    3. s.push(2);  
    4. s.push(3);  
    5.   
    6. cout << s.top() << endl;   //3  
    7. s.pop();  
    8. cout << s.top() << endl;   //2  

    栈没有clear或者erase函数,如果想要清空一个栈,需要循环的调用出栈函数。

    1. stack<int>s;  
    2. //s.erase(); //error  
    3. //s.clear(); //error  
    4. s.push(1);  
    5. s.push(2);  
    6. s.push(3);  
    7. cout << s.size() << endl;   //3  
    8. while(!s.empty())  
    9.     s.pop();  
    10. cout << s.size() << endl;    //0  

    7、swap()

    交换两个栈的内容(所有元素),这个函数通过非成员函数swap()来交换底层容器,时间复杂度O(1)

    cplusplus的例子

    1. // stack::swap  
    2. #include <iostream>       // std::cout  
    3. #include <stack>          // std::stack  
    4.   
    5. int main ()  
    6. {  
    7.   std::stack<int> foo,bar;  
    8.   foo.push (10); foo.push(20); foo.push(30);  
    9.   bar.push (111); bar.push(222);  
    10.   
    11.   foo.swap(bar);  
    12.   
    13.   std::cout << "size of foo: " << foo.size() << '\n';  
    14.   std::cout << "size of bar: " << bar.size() << '\n';  
    15.   
    16.   return 0;  
    17. }  

    8、运算符重载

    1. (1)==用于比较两个栈是否相等,首先判断大小是否相等,然后再通过operator ==判断元素之间是否相等,将会在第一个不相等的地方停止  
    2.   
    3. template <class T, class Container>  
    4.   bool operator== (const stack<T,Container>& lhs, const stack<T,Container>& rhs);  
    5. (2)!= 和==是相反的。只要大小不同或者有一个元素不一样就是不相等的    
    6.       
    7.   
    8.     template <class T, class Container>  
    9.   
    10.       bool operator!= (const stack<T,Container>& lhs, const stack<T,Container>& rhs);  
    11.   
    12.       
    13.   
    14.     (3)从第一元素开始比较当发现大于或者等于时停止,如果一个栈是另一个栈的前缀,那么长的栈大。下同   
    15.   
    16.       
    17.   
    18.     template <class T, class Container>  
    19.   
    20.       bool operator<  (const stack<T,Container>& lhs, const stack<T,Container>& rhs);  
    21.   
    22.       
    23.   
    24.     (4)      
    25.   
    26.       
    27.   
    28.     template <class T, class Container>  
    29.   
    30.       bool operator<= (const stack<T,Container>& lhs, const stack<T,Container>& rhs);  
    31.   
    32.       
    33.   
    34.     (5)      
    35.   
    36.       
    37.   
    38.     template <class T, class Container>  
    39.   
    40.       bool operator>  (const stack<T,Container>& lhs, const stack<T,Container>& rhs);  
    41.   
    42.       
    43.   
    44.     (6)      
    45.   
    46.       
    47.   
    48.     template <class T, class Container>  
    49.   
    50.       bool operator>= (const stack<T,Container>& lhs, const stack<T,Container>& rhs);  
    51.   
    52.       
    1.     stack<int>l1;  
    2.     l1.emplace(1);  
    3.     l1.emplace(2);  
    4.     l1.emplace(3);  
    5.     stack<int>l2;  
    6.     l2.emplace(1);  
    7.     l2.emplace(2);  
    8.     cout << boolalpha << (l1 > l2) << endl;   //T  
    9.     cout << boolalpha << (l1 == l2) << endl;   //F  
    10.     cout << boolalpha << (l1 != l2) << endl;   //T  

    四、结语

    栈是一种特别常用的数据结构,在各种编程语言或者是操作系统内部,都能见到。常见的DFS算法,递归算法;上下文切换,进程调度,以及寄存器本身。

    展开全文
  • java中Stack类总结

    千次阅读 2018-06-26 10:48:49
    Stack是栈;特点是:先进后出。它通过5个操作对类vector进行扩展,允许将向量视为堆栈。 它提供了通常的 push 和 pop 操作,以及取栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并...

     Stack是栈;特点是:先进后出。它通过5个操作对类vector进行扩展,允许将向量视为堆栈。

     它提供了通常的 push 和 pop 操作,以及取栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到栈顶距离的 search 方法。 

     E push(E item) 
              把项压入堆栈顶部。 
     E pop() 
              移除堆栈顶部的对象,并作为此函数的值返回该对象。 
     E peek() 
              查看堆栈顶部的对象,但不从堆栈中移除它。 
     boolean empty() 
              测试堆栈是否为空。  
     int search(Object o) 
              返回对象在堆栈中的位置,以 1 为基数。

    public class Stack<> extends  vector<>.        Stack的上层接口和实现类是: 
    Stack extends Vector extends java.util.AbstractList implements java.util.List,(Vector是线程安全的)。

    import java.util.Stack;
    
    public class StackX {
    	public static void main(String[] args) {
    		stackMethod();
    	}
    	//stack operate
    	public static void stackMethod(){
    		//定义一个Integer泛型的Stack
    		Stack<Integer> stack = new Stack<Integer>();
    		System.out.println("新建栈stack是否为空 : "+(stack.empty() ? "空" : stack.size()));
    		//push : 把项压入堆栈顶部,返回值泛型指定的类型
    		//此处将1到5压入栈中
    		stack.push(1);
    		stack.push(2);
    		stack.push(3);
    		stack.push(4);
    		stack.push(5);
    		System.out.println("将1到5按顺序压入栈中后为:"+stack);
    		//empty : 测试堆栈是否为空,size() == 0,返回值boolean
    		System.out.println("值为1~5的栈中stack是否为空 : "+(stack.empty() ? "空" : stack.size()));
    		//search : 返回对象在堆栈中的位置,以 1 为基数,参数:search(Object o) ,返回值int
    		int oStack = stack.search(3);
    		System.out.println("查找栈stack中对象3的位置elementId为 : "+oStack);
    		//peek : 查看堆栈顶部的对象,但不从堆栈中移除它,返回值泛型指定的类型
    		int topElement =stack.peek();
    		System.out.println("查看stack的栈顶元素为 : "+topElement);
    		System.out.println("peek操作stack后为 : "+stack);
    		//pop : 移除堆栈顶部的对象,并作为此函数的值返回该对象,返回值泛型指定的类型
    		int oRemove = stack.pop();
    		System.out.println("移除stack栈顶的元素为 : "+oRemove);
    		System.out.println("pop操作移除stack栈顶元素后为 : "+stack);
    	}
    }

    输出为

    新建栈stack是否为空 : 空
    将1到5按顺序压入栈中后为:[1, 2, 3, 4, 5]
    值为1~5的栈中stack是否为空 : 5
    查找栈stack中对象3的位置elementId为 : 3
    查看stack的栈顶元素为 : 5
    peek操作stack后为 : [1, 2, 3, 4, 5]
    移除stack栈顶的元素为 : 5
    pop操作移除stack栈顶元素后为 : [1, 2, 3, 4]


    Stack和Collection的关系如下;


     代码如下:

    
    	import java.util.*;
    	/**
    	 * java中stack的使用方法,堆栈是一种"后进先出"(LIFO)的数据结构,只能在一端进行插入(称为"压栈")或删除(称为"出栈")数据的操作.
    	 * Java中,使用java.util.Stack类的构造方法创建对象
    	 * public class Stack extends vector
    	 * 构造方法:public Stack()创建一个空Stack
    	 * 1.public push(item)把item压入栈顶.其作用与addElement(item)相同
    	 * 2.public pop移除栈顶对象,并作为函数的值返回该对象
    	 * 3.public peek()查看栈顶对象而不移除它
    	 * 4.public boolean empty()测试堆栈是否为空
    	 * 5.public int search(Object object)返回对象在堆栈中的位置
    	 */
    	//import java.util.Enumeration;
    //	import java.util.Stack;
    
    	/**
    	 * 学习Stack的用法
    	 *
    	 *
    	 */
    	public class StackTest {
    		public static void main(String[] args) {
    			//创建堆栈对象
    			Stack stack=new Stack();
    			System.out.println("aaaa,bbbb,cccc三个元素入栈");
    			//向栈中压入字符串aaaa
    			stack.push("aaaa");
    			//显示栈中的所有元素
    			printStack(stack);
    			stack.push("bbbb");
    			printStack(stack);
    			stack.push("cccc");
    			printStack(stack);
    			String s=new String("aaaa");
    			System.out.println("元素aaaa在堆栈的位置"+stack.search(s));
    			s=new String("bbbb");
    			System.out.println("元素bbbb在堆栈的位置"+stack.search(s));
    			System.out.println("aaaa,bbbb,cccc三个元素出栈");
    			System.out.println("元素"+stack.pop()+"出栈");
    			printStack(stack);
    			System.out.println("元素"+stack.pop()+"出栈");
    			printStack(stack);
    			System.out.println("元素"+stack.pop()+"出栈");
    			printStack(stack);
    			
    		}
    		private static void printStack(Stack stack)
    		{
    			if(stack.empty())
    			{
    				System.out.println("堆栈是空的,没有元素");
    			}
    			else
    			{
    				System.out.print("堆栈中的元素:");
    				//得到Stack中的枚举对象
    				Enumeration items=stack.elements();
    				//显示枚举(stack)中的所有元素
    				while(items.hasMoreElements())
    				{
    					System.out.print(items.nextElement()+"");
    				}
    			}
    			System.out.println();//换行
    		}
    	}
    
    	
    
    
    

    输出的结果如下;


    展开全文
  • stack的常见用法

    万次阅读 2018-08-26 15:12:47
    stack翻译为栈,时STL中实现的一个后进先出的容器 1、stack的定义 【头文件】 #include&lt;stack&gt; using namespace; 定义方法与其他容器相同,typename可以任意基本类型数据类型或容器 stack&...

    stack翻译为栈,时STL中实现的一个后进先出的容器

    1、stack的定义

    【头文件】

    #include<stack>

    using namespace;

    定义方法与其他容器相同,typename可以任意基本类型数据类型或容器

    stack<typename> name;

    2、stack容器内元素的访问

    由于栈(stack)本身就是一种后进先出的数据结构

    在STL的stack中只能通过top()来访问栈顶元素

    #include<utility>
    #include<iostream>
    #include<stdio.h>
    #include<string>
    #include<algorithm>
    #include<map>
    #include<vector>
    #include<stack>
    using namespace std;
    int main()
    {
        stack<int> st;
        for(int i=1;i<=5;i++)
        {
            st.push(i);
        }
        printf("%d\n",st.pop());
        return 0;
    }
    

    3、stack常用函数

    ①push()

    入栈

    ②top()

    获得栈顶元素

    ③pop()

    弹出栈顶元素

    #include<utility>
    #include<iostream>
    #include<stdio.h>
    #include<string>
    #include<algorithm>
    #include<map>
    #include<vector>
    #include<stack>
    using namespace std;
    int main()
    {
        stack<int> st;
        for(int i=1;i<=5;i++)
        {
            st.push(i);
        }
        for(int i=1;i<=3;i++)
        {
            st.pop();
        }
        printf("%d\n",st.pop());
        return 0;
    }
    

    ④empty()

    可以检测stack内是否为空,返回true为空,返回false为非空

    ⑥size()

    返回stack内元素的个数

    4、stack的常见用途

    stack常用来模拟一些递归,防止程序对栈内存的限制而导致程序出错

    一般来说

    程序的栈内存空间很小

    对有些题目来说

    如果用普通的函数来进行递归

    一旦递归层数过深

    则会导致程序运行崩溃

    如果用栈来模拟递归算法的实现

    可以避免这一方面的问题

    知识点来自于《算法笔记》

    展开全文
  • 堆栈(stack)的四种类型

    千次阅读 2020-08-05 20:21:25
    堆栈严格来说应该叫做栈(stack),先入后出 四种类型:满增栈、满减栈、空增栈、空减栈。 满、空栈区别:根据当前指针所在位置是否有东西。 满栈(full stack):栈指针指向最后压入栈的数据,数据入栈时,sp先减...

    堆栈严格来说应该叫做栈(stack),先入后出

    四种类型:满增栈、满减栈、空增栈、空减栈。

     

    满、空栈区别:根据当前指针所在位置是否有东西。

    满栈(full stack):栈指针指向最后压入栈的数据,数据入栈时,sp先减一(或加一)再入栈。

    空栈(empty stack):栈指针指向下一个将要放入数据的位置,数据入栈时,先入栈sp再减一(或加一)。

     

    增、减栈区别:根据堆栈的生成方向不同。

    递增堆栈(ascending stack):堆栈由低地址向高地址生长。

    递减堆栈(secending stack):堆栈由高地址向低地址生长。

     

    总结:

     

    满栈进栈是先移动指针再存;

    满栈出栈是先出数据再移动指针;

    空栈进栈先存再移动指针;

    空栈出栈先移动指针再取数据。

     

    ARM处理器核对于两种生长方式的堆栈均支持。

     

     

     

     

     

    展开全文
  • C++中stack详解

    万次阅读 2018-10-02 00:38:16
    C++ Stack(堆栈) 是一个容器类的改编,为程序员提供了堆栈的全部功能,——也就是说实现了一个先进后出(FILO)的数据结构。 c++ stl栈stack的头文件为:  #include &lt;stack&gt;  c++ stl栈stack的...
  • stack用法

    千次阅读 2018-05-31 23:34:17
    一、简介 stack是一种容器适配器(STL的容器分为顺序容器和关联容器,容器适配器,是对这两类容器进行包装得到的具有更强的约束力的容器),被设计来用于操作先进后出(FILO)结构的情景,在这种情况下, 元素的...
  • Java 栈 stack方法总结

    万次阅读 2019-01-05 23:19:53
    前言 最近开始在重新刷leetcode,发现之前刷过的很多算法题现在又陆陆续续忘记了。...Stack来自于Vector,那么显然stack的底层实现是数组。 Stack的方法 java中Stack只有一个无参构造函数。 属于stack自...
  • numpy中stack()的方法的作用

    万次阅读 2018-04-26 16:29:43
    np.stack() np.stack()方法大家肯定经常遇到,但是对于stack()的具体作用可能不一定非常明确,这里结合实例以及官方文档作用解释。 Parameters: arrays : sequence of array_like Each array must have the ...
  • java数据结构与算法之栈(Stack)设计与实现

    万次阅读 多人点赞 2017-01-04 17:06:58
    【版权申明】转载请注明出处(请尊重原创,博主保留追究权) ... 出自【zejian的博客】 关联文章:java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良...
  • java里有数字long来表示大的整数,如果两个数字的范围超过了long,要做加法算法怎么做呢?
  • 博主在项目中遇到了这个需求,开始用的int类型进行运算,字段是存的字节,然后后台进行相应的逻辑运算返回给前台,前台来转化成GB。大家都知道1GB=1024MB,1MB=1024KB,1KB=1024Byte,所以1GB=1024*1024*1024=...
  • 一、 实验目的1. 熟悉栈的特点(先进后出)及栈的抽象类定义;2. 掌握栈的顺序存储结构和链式存储结构的实现;3. 熟悉队列的特点(先进先出)及队列的抽象类定义;4. 掌握栈的顺序存储结构和链式存储结构的实现...
  • Stack.Peek 与 stack.pop 的区别

    万次阅读 多人点赞 2013-09-06 10:58:51
    相同点:大家都返回栈顶得值。 不同点:peek 不改变栈的值(不删除栈顶的值),pop会把栈顶的值删除。
  • Try: Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output
  • 错误直译过来就是“栈溢出”,出现这个错误的原因是因为我进行了递归运算,但是忘记添加判断条件,导致递归无线循环下去。。
  • Stack.peek()和Stack.pop()的区别

    万次阅读 2018-06-21 09:08:02
    1. Stack.peek() peek()函数返回栈顶的元素,但不弹出该栈顶元素。 2. Stack.pop() pop()函数返回栈顶的元素,并且将该栈顶元素出栈。
  • Java.util.Stack类的peek()方法

    万次阅读 2009-07-21 22:54:00
    java.util.Stack这个类不难,但需要注意其中的peek()方法: 查看栈顶对象而不移除它 import java.util.Date;import java.util.Stack;public class StackDemo { public static void main(String[] args) { Stack ...
  • 栈的C语言实现

    万次阅读 2019-12-03 09:24:44
    一个栈的C语言实现,函数声明放在stack.h头文件汇总,函数定义放在stack.c中,main.c 用来测试各个函数. 1.文件 stack.h // stack.h #ifndef __STACK_H__ #define __STACK_H__ typedef int DataType; typedef ...
  • 打包过程中,经常碰到这种问题,但是又看不到更多的日志,这就恼火了,于是google一番,看到不少大神的解决方法,这样可以更好地定位错误,也可得到更多的错误信息 stackoverflow 解决方法 ...
  • Maximum call stack size exceeded

    万次阅读 2019-05-23 09:44:51
    错误描述 直接上错误截图: 错误解析 以上错误的意思是 "超出最大调用堆栈大小" 出现这种错误最常见的原因是:在代码中的某个地方,您正在调用一个函数,该函数又调用另一个函数,依此类推,直到达到调用...
1 2 3 4 5 ... 20
收藏数 902,573
精华内容 361,029
关键字:

stack