数据结构第三章-栈

最新推荐文章于 2021-02-27 21:07:17 发布
最新推荐文章于 2021-02-27 21:07:17 发布
阅读量542 收藏 2
点赞数
分类专栏： 数据结构 一步一步学数据结构

转自：http://blog.csdn.net/hguisu/article/details/7674195

1．栈

1.1 栈的定义

栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。如下所示：


结论：后进先出（Last In First Out），简称为LIFO线性表。

栈的基本运算有六种：

构造空栈：InitStack(S)、

判栈空: StackEmpty(S)、

判栈满： StackFull(S)、

进栈： Push(S,x)、可形象地理解为压入，这时栈中会多一个元素

退栈： Pop(S) 、 可形象地理解为弹出，弹出后栈中就无此元素了。

取栈顶元素：StackTop(S),不同与弹出，只是使用栈顶元素的值，该元素仍在栈顶不会改变。


栈的应用实例：

1、数制转换

N = (N/d)*d + N%d；如（1348）十进制=（2504）八进制

while(N)

{

Push(S, N%8);

N = N/8;

}

在将栈S依次取出就是转换后的值。

2、括号匹配的检验

如([ ][ ])或[([ ][ ])]等为正确的格式。检验括号是否匹配的方法可用“期待的急迫程度”这个概念来描述。如[([ ][ ])]分别对应的标号为12345678。

在算法中设子一个栈，每读入一个括号，若是右括号，则或者使置于栈顶的最急迫的期待得以消解，或者是不合法的情况；若是左括号，则作为一个新的更急迫的期待压入栈中，自然使原有的在栈中的所有未消解的期待的急迫性都降了一级。另外在算法的开始和结束时，栈都应该是空的。

3、行编辑程序

允许用户输入出错，并在发现有误时可以及时更正。例如，当用户发现刚刚键入的一个字符是错的时候，可以补一个退格符“#”，以表示前一个字符无效；如果发现当前键入的行内差错较多或难以补救，则可以键入一个退行符“@”，以表示当前行中的字符均无效。如下

whli##ilr#e(s#*s)

outcha@putchar(*s=#++);

则实际有效的是下列两行：

while(*s)

putchar(*s++);

为此，可设这个输入缓冲区为一个栈结构，每当从终端接受了一个字符之后先作如下判别：如果它既不是退格符也不少退行符，则将该字符压入栈顶；如果是一个退格符，则从栈顶删去一个字符；如果是一个退行符，则将字符栈清为空栈。

4、迷宫求解（穷举求解）

5、表达式求值


    由于栈也是线性表，因此线性表的存储结构对栈也适用，通常栈有顺序栈和链栈两种存储结构，这两种存储结构的不同，则使得实现栈的基本运算的算法也有所不同。

我们要了解的是，在顺序栈中有"上溢"和"下溢"的概念。顺序栈好比一个盒子，我们在里头放了一叠书，当我们要用书的话只能从第一本开始拿(你会把盒子翻过来吗?真聪明^^)，那么当我们把书本放到这个栈中超过盒子的顶部时就放不下了(叠上去的不算，哼哼)，这时就是"上溢","上溢"也就是栈顶指针指出栈的外面，显然是出错了。反之，当栈中已没有书时，我们再去拿，看看没书，把盒子拎起来看看盒底，还是没有，这就是"下溢"。"下溢"本身可以表示栈为空栈,因此可以用它来作为控制转移的条件。

链栈则没有上溢的限制，它就象是一条一头固定的链子，可以在活动的一头自由地增加链环(结点)而不会溢出，链栈不需要在头部附加头结点，因为栈都是在头部进行操作的，如果加了头结点，等于要在头结点之后的结点进行操作，反而使算法更复杂，所以只要有链表的头指针就可以了。


1.2 栈的顺序存储

顺序栈的定义：

typedef struct{

SElemType *base;

SElemType *top;

int stacksize;

}SqStack;

其中stacksize指示栈的当前可使用的最大容量。栈的初始化操作为：按设定的初始化分配量进行第一次存储分配，base可称为栈底指针，在顺序栈中，它始终指向栈底的位置，若base的值为NULL，则表明栈结构不存在。称top为栈顶指针，其初值指向栈底，即top=base可作为栈空的标记，每当插入新的栈顶元素时，指针top增1；删除栈顶元素时，指针top减1，因此，非空栈中的栈顶指针始终在栈顶元素的下一个位置上。


使用c++的面向对象封装：

  1. // Test.cpp : Defines the entry point for the console application.  
  2. //  
  3. #include "stdafx.h"    
  4. #include <iostream>  
  5. using namespace std;  
  6. #define MAX 10 // MAXIMUM STACK CONTENT  
  7. class stack     
  8. {     
  9. private:     
  10.     int arr[MAX];   
  11.     int top;   
  12. public:     
  13.     stack()   
  14.     {     
  15.         inItStack();   
  16.     }  
  17.     /************************************************************************/  
  18.     /* 初始化栈                                                                     */  
  19.     /************************************************************************/  
  20.     void inItStack()   
  21.     {   
  22.         top=-1;   
  23.     }   
  24.     /************************************************************************/  
  25.     /* 入栈                                                                     */  
  26.     /************************************************************************/  
  27.     void push(int a)   
  28.     {     
  29.         top++;  
  30.         if(top < MAX)  {     
  31.             arr[top]=a;   
  32.         }   else   {
  33.     top--;     
  34.             cout<<"STACK FULL!!"<<top;     
  35.         }     
  36.     }     
  37.     /************************************************************************/  
  38.     /* 出栈                                                                     */  
  39.     /************************************************************************/  
  40.     int pop()  
  41.     {      
  42.         if(isEmpty())   {     
  43.             cout<<"STACK IS EMPTY ";  
  44.             return NULL;     
  45.         } else {     
  46.             int data=arr[top];   
  47.             arr[top]=NULL;   
  48.             top--;  
  49.             return data;   
  50.         }     
  51.     }     
  52.   
  53.     /************************************************************************/  
  54.     /* 是否为空                                                                     */  
  55.     /************************************************************************/  
  56.     bool isEmpty()  
  57.     {  
  58.         if(top == -1) return true;  
  59.         else return false;  
  60.     }  
  61. };     
  62. int main()     
  63. {     
  64.     Stack a;
        a.Push(1);
        a.Push(2);
        a.Push(3);
        a.Push(4);
        a.Push(5);
        a.Push(6);
        a.Push(7);
        a.Push(8);
        a.Push(9);
        a.Push(10);
        a.Push(11);
        std::cout<<"Pop is:"<<a.Pop()<<std::endl;
        a.Push(11);
        std::cout<<"Pop is:"<<a.Pop()<<std::endl;         
  65.     return 0;     
  66. }  

  1. //顺序栈   
  2. #include <stdio.h>   
  3. #include <stdlib.h>   
  4. #define    OK 1   
  5. #define ERROR 0   
  6. #define OVERFLOW -2   
  7. #define STACKINITSIZE 100//初始化空间分配量   
  8. #define STACKINCREASEMENT 10//分配增量   
  9. typedef char elemType;//元素类型  
  10.   
  11. typedef struct  
  12. {  
  13. elemType *top;  
  14. elemType *base;  
  15. int stacksize;  
  16. }SqStack;  
  17.   
  18. //初始化栈   
  19. int InitStack(SqStack *s)  
  20. {  
  21. s->base=(elemType *)malloc(STACKINITSIZE*sizeof(elemType));  
  22. if(!s->base) exit(OVERFLOW);  
  23. s->top=s->base;  
  24. s->stacksize=STACKINITSIZE;  
  25. return OK;  
  26. }  
  27.   
  28. //获取栈的长度(元素个数)   
  29. int StackLength(SqStack *s)  
  30. {  
  31. int length=0;  
  32. elemType *p=s->base;  
  33. while(p!=s->top)//自下朝上增加   
  34. {  
  35. p++;  
  36. length++;  
  37. }  
  38. return length;  
  39. }  
  40. //获取栈的长度（元素个数），另一种方法   
  41. void GetLength(SqStack *s)  
  42. {  
  43. printf("栈的元素个数为%d\n",s->top-s->base);  
  44. }  
  45.   
  46. //遍历栈，自顶向下   
  47. int StackTraverse(SqStack *s)  
  48. {  
  49. elemType *p=s->top;  
  50. printf("该栈自顶向下的元素为:\n");  
  51. while(p!=s->base)  
  52. {  
  53. p--;  
  54. printf("%c",*p);  
  55. }  
  56. printf("\n");  
  57. return OK;  
  58. }  
  59.   
  60. //获取栈顶元素   
  61. int GetTop(SqStack *s)  
  62. {  
  63. if(s->top==s->base)  
  64. printf("栈为空\n");  
  65. return ERROR;  
  66. printf("%c",*(s->top-1));  
  67. return OK;  
  68. }  
  69.   
  70. //插入值为e的栈顶元素   
  71. int Push(SqStack *s,elemType e)  
  72. {  
  73. if(s->top-s->base==s->stacksize)//栈满，插入栈顶元素需要重新分配空间  
  74. {  
  75. s->base=(elemType *)realloc(s->base,(s->stacksize+STACKINCREASEMENT)*sizeof(elemType));  
  76. if(!s->base) exit(OVERFLOW);  
  77. s->top=s->base+STACKINCREASEMENT;  
  78. }  
  79. //*(s->top++)=e;   
  80. *(s->top)=e;  
  81. s->top++;//top指向栈顶元素的上方，先赋值，再top++   
  82. return OK;  
  83. }  
  84.   
  85. //删除栈顶元素   
  86. int Pop(SqStack *s)  
  87. {  
  88. if(s->base==s->top)  
  89. {  
  90. printf("栈为空\n");  
  91. return ERROR;  
  92. }  
  93. //printf("已删除栈顶元素 %c\n",*(--s->top));   
  94. s->top--;  
  95. printf("已删除栈顶元素 %c\n",*(s->top));//top指向栈顶元素的上方，先top--，再输出值  
  96. return OK;  
  97. }  
  98. //判断栈是否为空   
  99. void StackEmpty(SqStack *s)  
  100. {  
  101. if(s->top==s->base)  
  102. printf("该栈为空\n");  
  103. else  
  104. printf("该栈不为空\n");  
  105. }  
  106. //清空栈   
  107. int ClearStack(SqStack *s)  
  108. {  
  109. if(s->base==s->top)  
  110. printf("栈已经为空\n");  
  111. else  
  112. {s->top = s->base;  
  113. printf("栈已经被清空\n");  
  114. }  
  115. return OK;  
  116. }  
  117.   
  118. main()  
  119. {  
  120. SqStack *s=(SqStack*)malloc(sizeof(SqStack));  
  121. InitStack(s);  
  122. StackEmpty(s);  
  123. printf("插入栈顶元素...\n");  
  124. Push(s,'a');  
  125. Push(s,'b');  
  126. Push(s,'c');  
  127. Push(s,'d');  
  128. StackEmpty(s);  
  129. StackTraverse(s);  
  130. printf("栈的元素个数为%d\n",StackLength(s));  
  131. //GetLength(s);   
  132. Pop(s);  
  133. StackTraverse(s);  
  134. //printf("栈的元素个数为%d\n",StackLength(s));   
  135. GetLength(s);  
  136. ClearStack(s);  
  137. StackEmpty(s);  
  138. printf("栈的元素个数为%d\n",StackLength(s));  
  139. //GetLength(s);   
  140. }   
上例转自http://blog.csdn.net/mpbchina/article/details/7384297

1.3 栈的链式存储
若是栈中元素的数目变化范围较大或不清楚栈元素的数目，就应该考虑使用链式存储结构。人们将用链式存储结构表示的栈称作"链栈"。链栈通常用一个无头结点的单链表表示。如图所示：


栈的操作是线性表操作的特例。

简单用c实现：

  1. // Test.cpp : Defines the entry point for the console application.    
  2. //    
  3. #include "stdafx.h"    
  4. #include <stdio.h>    
  5. #include "stdlib.h"  
  6. #include <iostream>  
  7. using namespace std;  
  8. //宏定义    
  9. #define TRUE   1    
  10. #define FALSE   0    
  11. #define OK    1    
  12. #define ERROR   0    
  13. #define INFEASIBLE -1    
  14. #define OVERFLOW -2   
  15. #define STACKEMPTY -3    
  16.   
  17. #define LT(a,b)   ((a)<(b))    
  18. #define N = 100           
  19.   
  20. typedef int Status;    
  21. typedef int ElemType;    
  22.   
  23. typedef struct LNode{    
  24.     ElemType        data;                 
  25.     struct LNode   *next;       
  26. }LNode, *LinkList;   
  27.   
  28. typedef struct stack{  
  29.     LinkList top;  
  30. } STACK;  
  31.   
  32.   
  33. /************************************************************************/  
  34. /*     接口： 
  35. */  
  36. /************************************************************************/  
  37. void InitStack(STACK &S);  
  38. void Push(STACK &S,ElemType e);  
  39. void Pop(STACK &S, ElemType *e);  
  40. ElemType GetTop(STACK S,ElemType *e);  
  41. int StackEmpty(STACK S);  
  42.   
  43. /************************************************************************/  
  44. /*  
  45. */  
  46. /************************************************************************/  
  47. void InitStack(STACK &S)  
  48. {  
  49.     S.top=NULL;  
  50. }  
  51.   
  52. /************************************************************************/  
  53. /* 入栈  
  54. */  
  55. /************************************************************************/  
  56. void Push(STACK &S,ElemType e)  
  57. {  
  58.     LinkList p;  
  59.     p = (LinkList )malloc(sizeof(LNode));  
  60.     if (!p) exit(OVERFLOW);  
  61.     p->data = e;  
  62.     p->next = S.top;  
  63.     S.top = p;  
  64. }  
  65. /************************************************************************/  
  66. /* 出栈 
  67. */  
  68. /************************************************************************/  
  69. void Pop(STACK &S, ElemType *e)  
  70. {  
  71.     LinkList p;  
  72.     if(StackEmpty(S)) exit(STACKEMPTY);  
  73.     *e = S.top->data;  
  74.     p = S.top;  
  75.     S.top = p->next;   
  76.     free(p);  
  77. }  
  78. /************************************************************************/  
  79. /* 获取栈顶元素内容 
  80. */  
  81. /************************************************************************/  
  82. ElemType GetTop(STACK S, ElemType *e)  
  83. {  
  84.     if(StackEmpty(S)) exit(STACKEMPTY);  
  85.     *e = S.top->data;  
  86. }  
  87.   
  88. /************************************************************************/  
  89. /* 判断栈S是否空  
  90. */  
  91. /************************************************************************/  
  92. int StackEmpty(STACK S)   
  93. {  
  94.     if(S.top==NULL) return TRUE;  
  95.     return   FALSE;  
  96. }  
  97.   
  98. void main()    
  99. {    
  100.   
  101.     STACK S;  
  102.     InitStack( S);  
  103.     Push(S, 3);  
  104.     Push(S, 4);  
  105.     ElemType e;  
  106.     Pop(S,&e);  
  107.     cout<<"Pop elem:"<<e;  
  108. }    

1.4 栈的应用

1)  数制转换

2）语法词法分析

3）表达式求值等


1.5 栈的递归和实现

汉诺塔的问题：

解决：

1）如果有一个盘子，直接从X移到Z即可。
2）如果有n个盘子要从X移到Z，Y作为辅助。问题可以转化为，先将上面n-1个从X移动到Y，Z作为辅助，然后将第n个从X移动到Z，最后将剩余的n-1个从Y移动到Z，X作为辅助。

完整实现代码，包括栈的实现：

  1. // Test.cpp : Defines the entry point for the console application.    
  2. //    
  3. #include "stdafx.h"    
  4. #include <stdio.h>    
  5. #include "stdlib.h"  
  6. #include <iostream>  
  7. using namespace std;  
  8. //宏定义    
  9. #define TRUE   1    
  10. #define FALSE   0    
  11. #define OK    1    
  12. #define ERROR   0    
  13. #define INFEASIBLE -1    
  14. #define OVERFLOW -2   
  15. #define STACKEMPTY -3    
  16.   
  17. #define LT(a,b)   ((a)<(b))    
  18. #define N = 100           
  19.   
  20. typedef int Status;    
  21. typedef int ElemType;    
  22.   
  23. typedef struct LNode{    
  24.     ElemType        data;                 
  25.     struct LNode   *next;       
  26. }LNode, *LinkList;   
  27.   
  28. typedef struct stack{  
  29.     LinkList top;  
  30. } STACK;  
  31.   
  32.   
  33. /************************************************************************/  
  34. /*     接口： 
  35. */  
  36. /************************************************************************/  
  37. void InitStack(STACK &S);  
  38. void Push(STACK &S,ElemType e);  
  39. void Pop(STACK &S, ElemType *e);  
  40. ElemType GetTop(STACK S,ElemType *e);  
  41. int StackEmpty(STACK S);  
  42.   
  43. /************************************************************************/  
  44. /*  
  45. */  
  46. /************************************************************************/  
  47. void InitStack(STACK &S)  
  48. {  
  49.     S.top=NULL;  
  50. }  
  51.   
  52. /************************************************************************/  
  53. /* 入栈  
  54. */  
  55. /************************************************************************/  
  56. void Push(STACK &S,ElemType e)  
  57. {  
  58.     LinkList p;  
  59.     p = (LinkList )malloc(sizeof(LNode));  
  60.     if (!p) exit(OVERFLOW);  
  61.     p->data = e;  
  62.     p->next = S.top;  
  63.     S.top = p;  
  64. }  
  65. /************************************************************************/  
  66. /* 出栈 
  67. */  
  68. /************************************************************************/  
  69. void Pop(STACK &S, ElemType *e)  
  70. {  
  71.     LinkList p;  
  72.     if(StackEmpty(S)) exit(STACKEMPTY);  
  73.     *e = S.top->data;  
  74.     p = S.top;  
  75.     S.top = p->next;   
  76.     free(p);  
  77. }  
  78. /************************************************************************/  
  79. /* 获取栈顶元素内容  
  80.  
  81. */  
  82. /************************************************************************/  
  83. ElemType GetTop(STACK S, ElemType *e)  
  84. {  
  85.     if(StackEmpty(S)) exit(STACKEMPTY);  
  86.     *e = S.top->data;  
  87. }  
  88. void printStack(STACK S){  
  89.     LinkList p;  
  90.     p = S.top;  
  91.     printf("栈： ");  
  92.     while (p) {  
  93.         printf("%d ", p->data);  
  94.         p = p->next;  
  95.     }  
  96. }  
  97. /************************************************************************/  
  98. /* 如果有一个盘子，直接从X移到Z即可。 
  99. 如果有n个盘子要从X移到Z，Y作为辅助。问题可以转化为，先将上面n-1个从X移动到Y，Z作为辅助，然后将第n个从X移动到Z，最后将剩余的n-1个从Y移动到Z，X作为辅助。 
  100. */  
  101. /************************************************************************/  
  102.   
  103. void move(STACK &Sa,STACK &Sb)  
  104. {     
  105.     ElemType e;  
  106.     Pop(Sa,&e);  
  107.     Push(Sb, e);  
  108. }  
  109. void hanoi(int n,STACK  &X,STACK &Y,STACK &Z)  
  110. {  
  111.     if(n==1) return move(X, Z);     //将圆盘1号直接移到z  
  112.     hanoi(n-1,X,Z,Y);               //将x上的1大n-1圆盘移到y，z做辅助塔  
  113.     move(X, Z);                     //将编号为n的圆盘移z  
  114.     hanoi(n-1,Y,X,Z);               //将y上的1大n-1圆盘移到z，x做辅助塔  
  115. }  
  116.   
  117. /************************************************************************/  
  118. /* 判断栈S是否空  
  119. */  
  120. /************************************************************************/  
  121. int StackEmpty(STACK S)   
  122. {  
  123.     if(S.top==NULL) return TRUE;  
  124.     return   FALSE;  
  125. }  
  126.   
  127. void main()    
  128. {    
  129.   
  130.     STACK Sx, Sy,Sz;  
  131.     InitStack( Sx);  
  132.     InitStack( Sy);  
  133.     InitStack( Sz);  
  134.     int i, n = 10;  
  135.     for (i = 10 ; i>=1 ;i--) {  
  136.         Push(Sx, i);  
  137.     }  
  138.     printStack(Sx);  
  139.     hanoi(n,  Sx,Sy,Sz);  
  140.     printStack(Sz);  
  141. }    


2023王道考研数据结构第三章---栈
weixin_52572034的博客
08-30 1013
2023王道考研数据结构第三章---栈
数据结构之栈
weixin_30869099的博客
08-20 168
栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。所以具有先进后出的特点。 栈的基本运算有六种： 构造空栈：InitStack(S)、 判栈空: StackEmpty(S)、 判栈满：StackFull(S)、 进栈：Push(S,x)、可形象地理解为压入，这时栈中会多一个元素 退栈：Pop(S) 、 可形象地理解为弹出，弹出后栈...
数据结构-栈
weixin_45666566的博客
04-18 330
栈一.定义：二.特点三.时间复杂度 一.定义： 栈是一种特殊的线性表，简称为LIFO线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行，遵循后进先出的原则。 二.特点 1）只允许在一端进行插入和删除的线性表。 2）栈的插入操作称为压栈（push），栈的取出操作称为出栈（pop）。 3）栈的存储结构分为顺序存储和链式存储，顺序存储称为顺序栈，链式存储称为链式栈。 三.时间复杂度...
顺序栈的应用：括号匹配（内含原理和完整代码实现）
weixin_46772309的博客
02-21 2935
一、原理 题设：在表达式中，只有【】和（）两种括号，如（【】）【（【】【】）】等为正确格式，【（】）或【（）或（（）】）均为不正确格式。编写程序检验表达式序列是否正确。 检验方法描述：“期待的急迫程度” 可能出现的不匹配的情况： ①到来的有括号不是所“期待的” ②盗来的是“不速之客”； ③直到结束，也没有到来所“期待”的括号； 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as
程序内存空间布局以及对栈顶，栈底的理解
我也想不到啥名字好
02-24 1万+
（1）ESP：栈指针寄存器(extended stack pointer)，其内存放着一个指针，该指针永远指向系统栈最上面一个栈帧的栈顶。 由于栈的地址大小是从上到下从大到小，所以ESP指在栈的最底端。（2）EBP：基址指针寄存器(extended base pointer)，其内存放着一个指针，该指针永远指向系统栈最上面一个栈帧的底部。指在栈的最顶端。eax一般用来保存函数的返回值，记住esp......
算法为急迫程度的符号匹配
05-08
数据结构，用堆栈的方法进行符号匹配，算法是期待的急迫程度
数据结构作业：第三章-栈和队列题目.docx
12-17
本文档旨在提供一个详细的知识点总结，涵盖数据结构第三章中的栈和队列概念。通过对题目的逐一分析，我们将对栈和队列的基本概念、特点、操作和应用进行总结。 栈的基本概念 栈是一种后进先出（LIFO）的数据结构，...
数据结构作业：第三章-栈和队列作业答案.docx
12-14
本资源摘要信息是关于数据结构第三章栈和队列的作业答案，涵盖了栈和队列的基本概念、操作原则、特点及应用场景。下面是对该资源的详细解读： 1. 栈的操作原则 栈是一种 Last-In-First-Out（后进先出）的数据结构...
《数据结构》第三章-栈与队列 思维导图
最新发布
01-11
栈及栈的特性、队列及队列的特性、循环队列、链队列、共享栈等
《数据结构》习题汇编03-第三章-栈与队列-试题.pdf
10-31
第三章栈和队列习题汇编主要涵盖了栈和队列的基本概念、实现方式、操作特点等知识点。下面对每个知识点进行详细的解释： 1. 栈的插入和删除操作在栈顶进行。栈的这种特点是为了实现后进先出的原则，即最后插入的...
何谓"自顶向下"，何谓"自底向上"
热门推荐
Cat的专栏
03-05 3万+
相信每一个coder都听说过“自顶向下”以及“自底向上”这两个名词。 我也是很早就听说过这两个名词，感觉是”不明觉厉”。 有一天，我打电话给一个做C语言开发的朋友说，我说我一直在做Java，想学一点C，问他有什么好的建议。 他说，他也有类似的想法，他说他一直在做C，想有机会学一点Java.然后他补充一句：他这是自底向上的学习，而我这叫自顶向下的学习。 我当时一愣，不愧是老司机：原来
Java实现括号匹配校验
朝花夕拾
02-21 6263
检测括号是否匹配的方法可用“期待的急迫程度”这个概念来描述。 /** * 括号匹配校验 * [ ( [ ] [ ] ) ] * 1 2 3 4 5 6 7 8 */ public class BracketMatchTest { public static void main(String[] args) { // TODO Auto-generated method stu
java打开文件查询括号匹配_用栈实现括号匹配检验（java）
weixin_39625563的博客
02-27 417
假设表达式中允许包含三种括号：大括号，中括号和小括号，其中嵌套的顺序随意，即([ ]())或{([ ])}等为正确的格式，[ ( ] ) 或 ( [ ) )均为不正确的格式。检验括号是否匹配的方法可用“期待的急迫程度”这个概念来描述。例如考虑下列括号序列：[ ( [][]) ]12 34567 8当计算机接收第一个括号后，它期待着与其匹配的第八个括号的出现，然而等来的却是第二个括号，此时第一个括号...
括号匹配的检验
xinda的博客
10-13 1440
一、题目 ◆3.19④ 假设一个算术表达式中可以包含三种括号：圆括号"(" 和 ")"，方括号"["和"]"和花括号"{"和"}"，且这三种括号可按任意的 次序嵌套使用（如：…[…{…}…[…]…]…[…]…(…)…）。编写判别给定表达 式中所含括号是否正确配对出现的算法(已知表达式已存入数据元素 为字符的顺序表中)。  实现下列函数： Status MatchCheck(S
栈的应用实践——括号匹配的检验
lan_777的博客
04-24 1985
目的：检验一个字符串中的大括号，中括号，小括号是否匹配。 方法：数据结构c语言版提出的期待的急迫程度描述这个问题，具体的思路为： 处于栈顶的括号总是最急迫的期待着和下一个读入的括号进行匹配 如果下一个括号可以匹配，那么栈顶括号出栈，之后新的栈顶处于最急迫的地位，或者空栈继续读入； 如果下一个括号不可以匹配栈顶，则这个括号进栈并成为新的栈顶，成为最急迫的元素，原先的急迫度则降了
括号的匹配问题
houcunyue的专栏
05-07 1023
括号的匹配问题。即：[ ] { } ( )      判断给定的括号序列是否合法。 可用“期待的急迫程度”这一概念来解决。即：先满足急迫程度最强的需求。 import java.util.Stack; public class Test {      private static Stack s=new Stack();    public static boolean compare
网易2016年Java工程师实习编程题目之括号匹配的验证
小嗨嗨的博客
03-25 770
题目描述：一个字符串中包含圆括号（）、中括号[ ]、大括号{ }，其嵌套的顺序随意。即()(){({})([])}是有效的，([)(]){]}是无效的。验证括号是否匹配的方法就是用“期待的急迫程度”这个概念来解决。关于“期待的急迫程度”概览大家自己晚上查阅了解。 package neteaseprograme; import java.util.Stack; public class
掌握数据结构第三章：栈与队列详解
本资源主要介绍了数据结构中的第三章内容——栈。栈是一种特殊的线性数据结构，其特点是只能在表的一端进行插入（进栈）和删除（出栈）操作，具有明确的栈顶和栈底，栈顶作为唯一可进行操作的端点。栈的基本概念包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值