精华内容
下载资源
问答
  • 顺序存储:在内存中分配一个数组空间,注意在顺序中有”上溢”(栈满)和”下溢”(空)的概念,所以每次操作时要先判断满栈空栈。 链式存储:控制入栈出栈的端口,栈顶一般是链表的头,第一个节点,底一般...

    图片名称

    栈:

    先进后出,栈是一种只能在一端进行插入和删除操作的特殊线性表。
    图片名称

    栈的存储结构:

    1. 顺序存储:在内存中分配一个数组空间,注意在顺序栈中有”上溢”(栈满)和”下溢”(栈空)的概念,所以每次操作时要先判断满栈或空栈。
    2. 链式存储:控制入栈出栈的端口,栈顶一般是链表的头,第一个节点,栈底一般是最后一个节点。(可以避免顺序存储的溢出),同时节省空间,要多少,申请多少。链表的运用中同时要注意一旦申请了,最后要记得释放,不然会带来不可预计的后果。下面是链式存储的一些操作。

    队列

    先进先出,队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。队列中没有元素时,称为空队列。

    队列的存储结构

    1. 顺序存储:
      建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间,并设置两个指针进行管理。一个是队头指针front,它指向队头元素;另一个是队尾指针rear,它指向下一个入队元素的存储位置,队列元素的个数不断变化,队列所占的存储空间也在为队列结构所分配的连续空间中移动。
      图片名称

      顺序队列中的溢出现象:

      1. ”下溢”现象:当队列为空时,做出队运算产生的溢出现象。“下溢”是正常现象,常用作程序控制转移的条件。
      2. “真上溢”现象:当队列满时,做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态,应设法避免。
      3. “假上溢”现象:由于入队和出队操作中,头尾指针只增加不减小,致使被删元素的空间永远无法重新利用。当队列中实际的元素个数远远小于向量空间的规模时,也可能由于尾指针已超越向量空间的上界而不能做入队操作。该现象称为”假上溢”现象。

      循环队列:

      为了解决”假上溢”现象,使队列空间能重复使用,往往对队列的使用方法稍加改进:无论插入或删除,一旦rear指针增1或front指针增1 时超出了所分配的队列空间,就让它指向这片连续空间的起始位置。

      循环队列的基本运算:

      1. 队列长度:(Q.rear - Q.front + MaxSize) % MaxSize;
      2. 队列满:(Q.rear + 1) % MaxSize == Q.front;
      3. 队列空:Q.rear == Q.front;
      4. 入队:Q.rear + 1;
      5. 出队:Q.front +1;
    2. 链式存储:
      基于链表的队列,要动态创建和删除节点,效率较低,但是可以动态增长。

    在vs中包含了栈和队列的标准库

    #include<stack>
    #include<queue>
    定义栈如下:
    stack<int> stk;
    定义队列如下:
    queue<int> q;
    栈提供了如下的操作
    s.empty()               如果栈为空返回true,否则返回false  
    s.size()                返回栈中元素的个数  
    s.pop()                 删除栈顶元素但不返回其值  
    s.top()                 返回栈顶的元素,但不删除该元素  
    s.push()                在栈顶压入新元素  
    //---------------------------------------------------------------
    q.empty()               如果队列为空返回true,否则返回false  
    q.size()                返回队列中元素的个数  
    q.pop()                 删除队列首元素但不返回其值  
    q.front()               返回队首元素的值,但不删除该元素  
    q.push()                在队尾压入新元素  
    q.back()                返回队列尾元素的值,但不删除该元素  
    
    展开全文
  • 栈的初始化及栈帧概念解析

    千次阅读 2016-11-03 23:29:12
    2、根据SP指针指向位置,可分为 满栈空栈  满栈:当sp指针总是指向最后压入堆栈 数据(ARM采用满栈)   空栈:当堆栈指针SP总是指向下一个将 要放入数据空位置。   3、根据SP指针移动方向...
    1、栈:FILO先进后出的数据结构
    栈底是第一个进栈的数据的位置(压箱 底) 
    栈顶是最后一个进栈的数据位置

    2、根据SP指针指向的位置,栈可分为 满栈和空栈 
    满栈:当sp指针总是指向最后压入堆栈 的数据(ARM采用满栈)
     
    空栈:当堆栈指针SP总是指向下一个将 要放入数据的空位置。
     

    3、根据SP指针移动的方向,可分为升 栈和降栈 
    升栈:随数据的入栈,SP由低地址--> 高地址 

    降栈:随数据的入栈,SP由高地址--> 低地址(ARM采用降栈)
     

    4、栈帧:存储在用户栈上的(当然内核栈同样适用)每一次函数调用涉及的相关信息的记录单元 ; 栈帧(stack frame)就是一个函数所使用的那部分栈,所有函数的栈帧串起来就组成了一个完整的栈。
    栈帧的两个边界分别有FP(R11)和SP(R13)L来限定。 
                    栈帧

    栈的作用:
    1)保存局部变量
    分析代码:
    [html] view plain copy
    1. #include <stdio.h>  
    2. int main()  
    3. {      
    4.     int a;  
    5.     a++;  
    6.     return a;  
    7. }</span>  

    反汇编之后的代码;
    [html] view plain copy
    1. stack: file format elf32-littlearm  
    2. Disassembly of section .text:  
    3.   
    4. 00000000 <main>:  
    5. #include <stdio.h>  
    6.   
    7. int main()  
    8. {  
    9.    0:   e52db004 push   {fp}     ; (str fp, [sp, #-4]!) @将栈帧底部指针FP压入栈中;创建属于main函数的栈帧。  
    10.    4:   e28db000 add    fp, sp, #0  ; 0x0 @fp指针为函数栈帧的底部,  
    11.    8:   e24dd00c sub    sp, sp, #12 ; 0xc   @sp指针为栈帧的顶部,同时为栈的栈顶。  
    12.     int a;  
    13.   
    14.     a++;  
    15.    c:   e51b3008 ldr    r3, [fp, #-8]   @由此三句可知变量a在栈帧中执行了加法操作,及栈帧具有保存局部变量的作用  
    16.   10:   e2833001 add    r3, r3, #1  ; 0x1  
    17.   14:   e50b3008 str    r3, [fp, #-8]  
    18.   
    19.     return a;  
    20.   18:   e51b3008 ldr    r3, [fp, #-8]  
    21. }  
    22. </span>  



    2)保存函数的参数 
    分析代码:
    [html] view plain copy
    1. <span style="font-size:18px;">#include <stdio.h>  
    2. void func1(int a,int b,int c,int d,int e,int f)  
    3. {  
    4.  int k;  
    5.  k=e+f;  
    6. }  
    7.   
    8. int main()  
    9. {  
    10.     func1(1,2,3,4,5,6);  
    11.     return 0;  
    12. }  
    13. 反汇编之后的代码;  
    14. void func1(int a,int b,int c,int d,int e,int f) @多于4个参数  
    15. {  
    16.    0:   e52db004 push   {fp}     ; (str fp, [sp, #-4]!)@保存main函数的栈帧底部指针FP  
    17.    4:   e28db000 add    fp, sp, #0  ; 0x0  
    18.    8:   e24dd01c sub    sp, sp, #28 ; 0x1c @由栈帧顶部指针SP创建一片栈帧保存子函数的前四个参数  
    19.    c:   e50b0010 str    r0, [fp, #-16]  @ a  
    20.   10:   e50b1014 str    r1, [fp, #-20]  @ b  
    21.   14:   e50b2018 str    r2, [fp, #-24]  @ c  
    22.   18:   e50b301c str    r3, [fp, #-28]  @ d  
    23.  int k;  
    24.  k=e+f;  
    25.   1c:   e59b3004 ldr    r3, [fp, #4]    @在子函数的栈帧中实现第五个参数与第六个参数的运算  
    26.   20:   e59b2008 ldr    r2, [fp, #8] @由ldr  r2, [fp, #8]知参数保存在main函数的栈帧中,并运算  
    27.   24:   e0833002 add    r3, r3, r2   @以子函数的栈帧底部指针(fp)做参考坐标实现对参数的查找  
    28.   28:   e50b3008 str    r3, [fp, #-8]  
    29. }  
    30.   2c:   e28bd000 add    sp, fp, #0  ; 0x0  
    31.   30:   e8bd0800 pop    {fp}  
    32.   34:   e12fff1e bx lr  
    33.   
    34. 00000038 <main>:  
    35.   
    36. int main()  
    37. {  
    38.   38:   e92d4800 push   {fp, lr}    @由于调用子函数,先保存main函数的栈帧底部指针FP和返回地址LR(当前PC指针的下一地址)  
    39.   3c:   e28db004 add    fp, sp, #4  ; 0x4 @可知先压入FP,后压入lr.把此时子函数(被调用者)的栈帧底部指针FP指向保存在子函数栈帧的main函数(调用者)的栈帧底部指针FP  
    40.   40:   e24dd008 sub    sp, sp, #8  ; 0x8   @创建栈  
    41.     func1(1,2,3,4,5,6);  
    42.   44:   e3a03005 mov    r3, #5  ; 0x5  
    43.   48:   e58d3000 str    r3, [sp]  
    44.   4c:   e3a03006 mov    r3, #6  ; 0x6  
    45.   50:   e58d3004 str    r3, [sp, #4]  
    46.   54:   e3a00001 mov    r0, #1  ; 0x1 @用通用寄存器保存前四个参数的值  
    47.   58:   e3a01002 mov    r1, #2  ; 0x2  
    48.   5c:   e3a02003 mov    r2, #3  ; 0x3  
    49.   60:   e3a03004 mov    r3, #4  ; 0x4  
    50.   64:   ebfffffe bl 0 <func1>  
    51.     return 0;  
    52.   68:   e3a03000 mov    r3, #0  ; 0x0  
    53. }  
    54.   6c:   e1a00003 mov    r0, r3  
    55.   70:   e24bd004 sub    sp, fp, #4  ; 0x4  
    56.   74:   e8bd4800 pop    {fp, lr}  
    57.   78:   e12fff1e bx lr</span>  


    注:C中,若函数的参数小于等于4个,则用通用寄存器保存其参数值,多于4个的参数保存在栈中

    3)保存寄存器的值
    分析代码:
    [html] view plain copy
    1. <span style="font-size:18px;">include <stdio.h>  
    2.   
    3. void func2(int a,int b)  
    4. {  
    5.     int k;  
    6.     k=a+b;  
    7. }  
    8.   
    9. void func1(int a,int b)  
    10. {  
    11.  int c;  
    12.  func2(3,4);  
    13.  c=a+b;  
    14. }  
    15.   
    16. int main()  
    17. {  
    18.     func1(1,2);  
    19.     return 0;  
    20. }</span>  

    反汇编之后的代码;
    [html] view plain copy
    1. <span style="font-size:18px;">void func2(int a,int b)  
    2. {  
    3.    0:   e52db004 push   {fp}     ; (str fp, [sp, #-4]!)  
    4.    4:   e28db000 add    fp, sp, #0  ; 0x0  
    5.    8:   e24dd014 sub    sp, sp, #20 ; 0x14  
    6.    c:   e50b0010 str    r0, [fp, #-16] @保存寄存器的值  
    7.   10:   e50b1014 str    r1, [fp, #-20]  
    8.     int k;  
    9.     k=a+b;  
    10.   14:   e51b3010 ldr    r3, [fp, #-16]  
    11.   18:   e51b2014 ldr    r2, [fp, #-20]  
    12.   1c:   e0833002 add    r3, r3, r2  
    13.   20:   e50b3008 str    r3, [fp, #-8]  
    14. }  
    15.   24:   e28bd000 add    sp, fp, #0  ; 0x0  
    16.   28:   e8bd0800 pop    {fp}  
    17.   2c:   e12fff1e bx lr  
    18.   
    19. 00000030 <func1>:  
    20.   
    21. void func1(int a,int b)  
    22. {  
    23.   30:   e92d4800 push   {fp, lr}  
    24.   34:   e28db004 add    fp, sp, #4  ; 0x4  
    25.   38:   e24dd010 sub    sp, sp, #16 ; 0x10  
    26.   3c:   e50b0010 str    r0, [fp, #-16] @代码44行调用func2函数后,又使用r0\r1保存参数,所以此时将r0\r1寄存器的  
    27.   40:   e50b1014 str    r1, [fp, #-20]  @值放入栈中  
    28.  int c;  
    29.  func2(3,4);  
    30.   44:   e3a00003 mov    r0, #3  ; 0x3  
    31.   48:   e3a01004 mov    r1, #4  ; 0x4  
    32.   4c:   ebfffffe bl 0 <func2>  
    33.  c=a+b;  
    34.   50:   e51b3010 ldr    r3, [fp, #-16]  
    35.   54:   e51b2014 ldr    r2, [fp, #-20]  
    36.   58:   e0833002 add    r3, r3, r2  
    37.   5c:   e50b3008 str    r3, [fp, #-8]  
    38. }  
    39.   60:   e24bd004 sub    sp, fp, #4  ; 0x4  
    40.   64:   e8bd4800 pop    {fp, lr}  
    41.   68:   e12fff1e bx lr  
    42.   
    43. 0000006c <main>:  
    44.   
    45. int main()  
    46. {  
    47.   6c:   e92d4800 push   {fp, lr}  
    48.   70:   e28db004 add    fp, sp, #4  ; 0x4  
    49.     func1(1,2);  
    50.   74:   e3a00001 mov    r0, #1  ; 0x1  
    51.   78:   e3a01002 mov    r1, #2  ; 0x2  
    52.   7c:   ebfffffe bl 30 <func1>  
    53.     return 0;  
    54.   80:   e3a03000 mov    r3, #0  ; 0x0  
    55. }  
    56.   84:   e1a00003 mov    r0, r3  
    57.   88:   e24bd004 sub    sp, fp, #4  ; 0x4  
    58.   8c:   e8bd4800 pop    {fp, lr}  
    59.   90:   e12fff1e bx lr</span>  




    初始化栈:即对SP指针赋予一个内存地址(统一标准:2440、6410、210)
    在内存的64MB位置即ldr sp, =0x34000000(2440)
    ldr sp, =0x54000000(6410)
    ldr sp, =0x24000000(210)
    由上可知ARM采用满栈(指向刚入栈的数据)、降栈(由高地址向低地址入栈)

    问题:因为ARM不同工作模式有不同的栈,定义栈的技巧是什么,避免定义相同的地址使用不同栈?


    转自:http://blog.csdn.net/u011467781/article/details/39559737


    展开全文
  • 重要术语:栈顶、底、空栈 特点:先进后出(FILO)、后进先出(LIFO) 2.栈的基本操作 创、销:Init_stack ( &S ) 初始化、Destroy_stack ( S ) 销毁。 增、删:Push ( &s, x )进栈【若X进栈作...

    1.栈的定义

    线性表:具有n个数据类型相同的数据元素的有序数列(n为表长)

    :只允许在一端插入或删除的线性表

    重要术语:栈顶、栈底、空栈

    特点:先进后出(FILO)、后进先出(LIFO)

    2.栈的基本操作

    创、销:Init_stack ( &S ) 初始化栈、Destroy_stack ( S ) 销毁栈。

    增、删:Push ( &s, x )进栈【若栈未满X进栈作栈顶元素】
    ------------Pop ( &s, &x )出栈【若栈不空,取出栈顶元素赋值给X】。

    :Gettop ( s, &x )若非空,返回栈顶元素。

    判空:Stack_empty ( S )栈为空返回true ,否则返回false。

    展开全文
  • 2、根据SP指针指向位置,可分为 满栈空栈  满栈:当sp指针总是指向最后压入堆栈 数据(ARM采用满栈)   空栈:当堆栈指针SP总是指向下一个将 要放入数据空位置。   3、根据SP指针移动...
    1、栈:FILO先进后出的数据结构
    栈底是第一个进栈的数据的位置(压箱 底) 
    栈顶是最后一个进栈的数据位置

    2、根据SP指针指向的位置,栈可分为 满栈和空栈 
    满栈:当sp指针总是指向最后压入堆栈 的数据(ARM采用满栈)
     
    空栈:当堆栈指针SP总是指向下一个将 要放入数据的空位置。
     

    3、根据SP指针移动的方向,可分为升 栈和降栈 
    升栈:随数据的入栈,SP由低地址--> 高地址 

    降栈:随数据的入栈,SP由高地址--> 低地址(ARM采用降栈)
     

    4、栈帧:存储在用户栈上的(当然内核栈同样适用)每一次函数调用涉及的相关信息的记录单元 ; 栈帧(stack frame)就是一个函数所使用的那部分栈,所有函数的栈帧串起来就组成了一个完整的栈。
    栈帧的两个边界分别有FP(R11)和SP(R13)L来限定。 
                    栈帧

    栈的作用:
    1)保存局部变量
    分析代码:
    #include <stdio.h>
    int main()
    {    
        int a;
        a++;
        return a;
    }</span>

    反汇编之后的代码;
    stack: file format elf32-littlearm
    Disassembly of section .text:
    
    00000000 <main>:
    #include <stdio.h>
    
    int main()
    {
       0:	e52db004 push	{fp}	 ; (str fp, [sp, #-4]!) @将栈帧底部指针FP压入栈中;创建属于main函数的栈帧。
       4:	e28db000 add	fp, sp, #0	; 0x0 @fp指针为函数栈帧的底部,
       8:	e24dd00c sub	sp, sp, #12	; 0xc	@sp指针为栈帧的顶部,同时为栈的栈顶。
        int a;
    
        a++;
       c:	e51b3008 ldr	r3, [fp, #-8]	@由此三句可知变量a在栈帧中执行了加法操作,及栈帧具有保存局部变量的作用
      10:	e2833001 add	r3, r3, #1	; 0x1
      14:	e50b3008 str	r3, [fp, #-8]
    
        return a;
      18:	e51b3008 ldr	r3, [fp, #-8]
    }
    </span>



    2)保存函数的参数 
    分析代码:
    <span style="font-size:18px;">#include <stdio.h>
    void func1(int a,int b,int c,int d,int e,int f)
    {
     int k;
     k=e+f;
    }
    
    int main()
    {
        func1(1,2,3,4,5,6);
        return 0;
    }
    反汇编之后的代码;
    void func1(int a,int b,int c,int d,int e,int f) @多于4个参数
    {
       0:	e52db004 push	{fp}	 ; (str fp, [sp, #-4]!)@保存main函数的栈帧底部指针FP
       4:	e28db000 add	fp, sp, #0	; 0x0
       8:	e24dd01c sub	sp, sp, #28	; 0x1c @由栈帧顶部指针SP创建一片栈帧保存子函数的前四个参数
       c:	e50b0010 str	r0, [fp, #-16]	@ a
      10:	e50b1014 str	r1, [fp, #-20]	@ b
      14:	e50b2018 str	r2, [fp, #-24]	@ c
      18:	e50b301c str	r3, [fp, #-28]	@ d
     int k;
     k=e+f;
      1c:	e59b3004 ldr	r3, [fp, #4]	@在子函数的栈帧中实现第五个参数与第六个参数的运算
      20:	e59b2008 ldr	r2, [fp, #8] @由ldr	r2, [fp, #8]知参数保存在main函数的栈帧中,并运算
      24:	e0833002 add	r3, r3, r2	 @以子函数的栈帧底部指针(fp)做参考坐标实现对参数的查找
      28:	e50b3008 str	r3, [fp, #-8]
    }
      2c:	e28bd000 add	sp, fp, #0	; 0x0
      30:	e8bd0800 pop	{fp}
      34:	e12fff1e bx	lr
    
    00000038 <main>:
    
    int main()
    {
      38:	e92d4800 push	{fp, lr}	@由于调用子函数,先保存main函数的栈帧底部指针FP和返回地址LR(当前PC指针的下一地址)
      3c:	e28db004 add	fp, sp, #4	; 0x4 @可知先压入FP,后压入lr.把此时子函数(被调用者)的栈帧底部指针FP指向保存在子函数栈帧的main函数(调用者)的栈帧底部指针FP
      40:	e24dd008 sub	sp, sp, #8	; 0x8	@创建栈
        func1(1,2,3,4,5,6);
      44:	e3a03005 mov	r3, #5	; 0x5
      48:	e58d3000 str	r3, [sp]
      4c:	e3a03006 mov	r3, #6	; 0x6
      50:	e58d3004 str	r3, [sp, #4]
      54:	e3a00001 mov	r0, #1	; 0x1 @用通用寄存器保存前四个参数的值
      58:	e3a01002 mov	r1, #2	; 0x2
      5c:	e3a02003 mov	r2, #3	; 0x3
      60:	e3a03004 mov	r3, #4	; 0x4
      64:	ebfffffe bl	0 <func1>
        return 0;
      68:	e3a03000 mov	r3, #0	; 0x0
    }
      6c:	e1a00003 mov	r0, r3
      70:	e24bd004 sub	sp, fp, #4	; 0x4
      74:	e8bd4800 pop	{fp, lr}
      78:	e12fff1e bx	lr</span>


    注:C中,若函数的参数小于等于4个,则用通用寄存器保存其参数值,多于4个的参数保存在栈中

    3)保存寄存器的值
    分析代码:
    <span style="font-size:18px;">include <stdio.h>
    
    void func2(int a,int b)
    {
        int k;
        k=a+b;
    }
    
    void func1(int a,int b)
    {
     int c;
     func2(3,4);
     c=a+b;
    }
    
    int main()
    {
        func1(1,2);
        return 0;
    }</span>

    反汇编之后的代码;
    <span style="font-size:18px;">void func2(int a,int b)
    {
       0:	e52db004 push	{fp}	 ; (str fp, [sp, #-4]!)
       4:	e28db000 add	fp, sp, #0	; 0x0
       8:	e24dd014 sub	sp, sp, #20	; 0x14
       c:	e50b0010 str	r0, [fp, #-16] @保存寄存器的值
      10:	e50b1014 str	r1, [fp, #-20]
        int k;
        k=a+b;
      14:	e51b3010 ldr	r3, [fp, #-16]
      18:	e51b2014 ldr	r2, [fp, #-20]
      1c:	e0833002 add	r3, r3, r2
      20:	e50b3008 str	r3, [fp, #-8]
    }
      24:	e28bd000 add	sp, fp, #0	; 0x0
      28:	e8bd0800 pop	{fp}
      2c:	e12fff1e bx	lr
    
    00000030 <func1>:
    
    void func1(int a,int b)
    {
      30:	e92d4800 push	{fp, lr}
      34:	e28db004 add	fp, sp, #4	; 0x4
      38:	e24dd010 sub	sp, sp, #16	; 0x10
      3c:	e50b0010 str	r0, [fp, #-16] @代码44行调用func2函数后,又使用r0\r1保存参数,所以此时将r0\r1寄存器的
      40:	e50b1014 str	r1, [fp, #-20]  @值放入栈中
     int c;
     func2(3,4);
      44:	e3a00003 mov	r0, #3	; 0x3
      48:	e3a01004 mov	r1, #4	; 0x4
      4c:	ebfffffe bl	0 <func2>
     c=a+b;
      50:	e51b3010 ldr	r3, [fp, #-16]
      54:	e51b2014 ldr	r2, [fp, #-20]
      58:	e0833002 add	r3, r3, r2
      5c:	e50b3008 str	r3, [fp, #-8]
    }
      60:	e24bd004 sub	sp, fp, #4	; 0x4
      64:	e8bd4800 pop	{fp, lr}
      68:	e12fff1e bx	lr
    
    0000006c <main>:
    
    int main()
    {
      6c:	e92d4800 push	{fp, lr}
      70:	e28db004 add	fp, sp, #4	; 0x4
        func1(1,2);
      74:	e3a00001 mov	r0, #1	; 0x1
      78:	e3a01002 mov	r1, #2	; 0x2
      7c:	ebfffffe bl	30 <func1>
        return 0;
      80:	e3a03000 mov	r3, #0	; 0x0
    }
      84:	e1a00003 mov	r0, r3
      88:	e24bd004 sub	sp, fp, #4	; 0x4
      8c:	e8bd4800 pop	{fp, lr}
      90:	e12fff1e bx	lr</span>




    初始化栈:即对SP指针赋予一个内存地址(统一标准:2440、6410、210)
    在内存的64MB位置即ldr sp, =0x34000000(2440)
    ldr sp, =0x54000000(6410)
    ldr sp, =0x24000000(210)
    由上可知ARM采用满栈(指向刚入栈的数据)、降栈(由高地址向低地址入栈)

    问题:因为ARM不同工作模式有不同的栈,定义栈的技巧是什么,避免定义相同的地址使用不同栈?

    展开全文
  • 栈的作用

    2016-06-01 11:23:16
    1 概念 是一种具有后进先出性质 ...根据SP指针指向位置,可以分为满栈空栈。  1. 满栈:当堆栈指针SP总是 指向最后压入堆栈数据  2. 空栈:当堆栈指针SP总是 指向下一个将要放入数据空位置  ARM采用
  • 详解

    千次阅读 2016-09-03 19:36:47
    1、栈概念  是一种具有后进先出性质数据组织方式,也就是说后放进去数据先取出,先... 根据SP指针指向位置,可以分为满栈空栈。  满栈:当堆栈指针SP总是指向最后压入堆栈数据。  空栈:当堆
  • 11.栈的初始化

    2019-09-21 12:19:04
    1.栈的概念: 2./空栈: 1.3:升/降: 1.4.桢的理解: 局部变量是保存在中的: Stack.c: 编译和反汇编: 传递参数: Func1: 保存寄存器...
  • 目录线性群体的概念数组类模板动态数组类模板程序链表的概念与结点类模板顺序访问的线性群体——链表类单链表的节点类模板在当前结点之后插入一个节点删除当前结点之后的结点链表的基本操作栈类栈的基本状态栈空栈满...
  • 初始化

    2017-08-15 09:04:00
    一、概念解析 1.1 概念- ...根据SP指针指向位置,可以分为满栈空栈。 1. 满栈:当堆栈指针SP总是指向最后压入堆栈数据 2. 空栈:当堆栈指针SP总是指向下一个将要放入数据空位置 ARM
  • 在程序中作用(ARM结构)

    千次阅读 2015-11-09 20:06:18
    首先读这篇文章之前,读者首先要了解两个基本的概念。  1、根据SP指针指向的位置,可以分为满栈空栈 (1)满栈: 堆栈指针SP总是指向最后压入堆栈的数据。 (2)空栈: 堆栈指针SP总是指向下一个将要放入数据...
  • 1.栈的基本概念 (Stack) 只允许在 一端 (这一端叫做栈顶) 进行插入或者删除操作 线性表 在中先进入栈元素会后出栈即:先进后出 (LIFO) 2.栈的基本操作 InitStack(&s) 初始化一个空栈S StackEmpty(S) ...
  • C语言 栈的基础知识

    2020-04-26 08:43:44
    栈的基本操作: 插入 删除 测试为空 检验已 出栈 构造原理 1.顺序存储 数组:STACK[0…M-1] 同时定义整型变量top来给出栈顶元素位置。 上溢:top=M-; 下溢:top=-1; 1)初始化 void initStack() {...
  • DataStructure part3

    2019-07-03 11:43:00
    1、栈的概念 是限定仅在表尾(栈顶)进行插入和删除操作的线性表 允许插入和删除的一端称为栈顶(top)、另一端为底(bottom),不含任何数据元素的称为空栈。又称为后进先出的线性表(LIFO结构) 的插入...
  • 根据sp指针指向位置,可以分为满栈空栈: 1.满栈,当堆栈指针sp总是指向最后一个压入堆栈数据 2.空栈,当堆栈指针sp总是指向下一个将要放入数据空位置 3.ARM采用满栈和降 根据sp指针移动...
  • 栈满条件:由于链表内存是随时申请和释放,所以在内存允许范围内是没有栈满条件。 进栈:将包含数据节点插入到头结点之后。 退:将头节点之后节点删除,并释放其所占内存。 代码 stack.c /*****...
  • 和队列

    2019-10-29 08:27:39
    1.栈的基本概念 栈的定义:是只允许在一端进行插入或删除线性表 栈的相关名词 : 1. 栈顶:线性表允许进行插入和删除那一端 2. 底:固定不进行插入或删除那一端 3. 空栈:不含任何元素空表 ...
  • 文章目录栈栈的基本概念栈栈顶空栈栈的操作特性栈的数学性质栈的基本操作栈的顺序存储结构顺序顺序栈的实现存储类型描述顺序栈的基本运算初始化判空进栈出栈读栈顶元素共享栈栈的链式存储结构存储类型描述...
  • 【数据结构】

    2017-03-27 08:19:14
    【1】栈的概念栈是限制在一端进行插入操作和删除操作的线性表(俗称堆栈), 允许进行操作的一端称为“栈顶”,另一固定端称为“底”,当中 没有元素时称为“空栈”。 【2】特点 ##后进先出(LIFO)。 【3】...
  • 模块四 栈和队列 本模块要点: 1理解栈的定义和特点 2掌握入栈出栈判断栈空栈满的算法 3理解队列的定义和特点 4掌握入队出队判断队空队满的算法 5循环队列的定义和操作 任务一 栈的概念和基本操作 子任务1 栈的概念 ...
  • 数据结构__和队列

    2020-09-29 20:04:45
    知识框架 概念 : 只允许在一端进行掺入或删除操作线性表。 栈顶: 线性表允许进行插入和删除那一端。...S, x):进栈,若S未,将x加入使之成为新栈顶。 Pop(&S, &x):出栈,若S非空,弹出
  • 这个题目作为栈的开始,我们需要先了解一下包括栈顶,底,栈顶指示器,空栈满栈,上溢,下溢等概念是一种特殊一种顺序表,栈的特性是后进先出,并且不能插队进栈出栈。栈的基本操作还是比较容易,...
  • 一、栈的基本概念 (Stack)只允许在一段端进行插入或删除操作线性表。可以进行出栈入栈操作一端称为栈顶(yop),无法进行出栈入栈操作一端称为底(bottom) 栈的基本操作: InitStack(&S):初始一个空栈S...
  • 目录基本概念:定义:基本操作:存储结构:顺序存储:判断空:进栈:出栈:读出栈顶元素:共享:链式存储:栈的应用:括号匹配:表达式求值:前缀表达式:中缀表达式后缀表达式转化思想:递归: 基本概念: 定义...
  • 数据结构(C++)_3-1

    2020-07-10 22:06:59
    3.空栈:不含任何数据元素的栈; 4.插入元素:入栈、进栈、压栈 5.删除元素:出栈、弹 6.特性:先进后出 7.例子:括号匹配、函数嵌套、网页浏览 01顺序 tip: 确定底:数组下标为0一端; 设变量top指示栈顶...
  • 类通常表示更加通用的概念 ADT使用通用的方式描述数据类型,而没有引入语言或实现细节 比如: 创建空栈 从栈顶添加数据 从栈顶删除数据 是否 是否空 stack.h //stack.h -- 堆栈的类定义实现 #...
  • 一、栈的初始化 1、概念解析 ...根据SP指针指向位置,可以分为满栈空栈。 1、满栈:当堆栈指针SP总是指向最后压入堆栈数据 2、空栈:当堆栈指针SP总是指向下一个将要放入数据空位置 ARM采用满栈
  • 从汇编语言写到c语言

    2016-03-08 21:37:00
    好了,言归正传,裸机程序没有操作系统的...空栈和满:这两个概念不是说的是空的还是满的空栈是指指针指向的是栈顶元素的下一个地址。满指的是栈顶指针指的是栈顶元素。2.升和降:升就是向上生长...

空空如也

空空如也

1 2 3
收藏数 41
精华内容 16
关键字:

栈空栈满的概念