数据结构学习笔记之栈

最新推荐文章于 2023-05-16 19:54:33 发布
最新推荐文章于 2023-05-16 19:54:33 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 栈 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mirale/article/details/38357933
版权

     栈(stack)  是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈项(top)，相应地，表头端称为栈底(bottom)。不含元素的空表称为空栈。

     栈有两种存储表示方法：顺序栈和链栈。顺序栈，即栈的顺序存储结构是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top指示栈顶元素在顺序栈中的位置。通常的习惯做法是以top=0表示空栈，鉴于C语言中数组的下标约定从0开始，则当以C作描述语言时，如此设定会带来很大不便；另一方面，由于栈在使用过程中所需最大空间的大小很难估计，因此，一般来说，在初始化设空栈时不应限定栈的最大容量。一个较合理的做法是：先为栈分配一个基本容量，然后在应用过程中，当栈的空间不够使用时再逐段扩大。为此，可设定两个常量：STACK_INIT_SIZE(存储空间初始分配量)和STACKINCREMENT(存储空间分配增量)，并以下述类型说明作为顺序栈的定义。

typedef struct {

        SElemType    *base;

        SElemType     *top;

         int    stacksize;

}SqStack;

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

                                                                                              图1 栈顶指针和栈中元素之间的关系      

栈的应用举例 

       由于栈结构具有后进先出的固有特性，致使栈成为程序设计中的有用工具。下面将讨论几个栈应用的典型例子。

1、数制转换

       十进制数N和其他d进制数的转换是计算机实现计算的基本问题，其解决方法很多其中一个简单算法基于下列原理：

        N = (N div d)*d+N mod d (其中：div为整除运算，mod为求余运算)

        例如：(1348)10 = (2504)8 ，其运算过程如下：

                                                                                  N                                  N div 8                                 N mod 8

                                                                                 1348                                 168                                       4

                                                                                  168                                    21                                        0

                                                                                   21                                       2                                         5

                                                                                   2                                          0                                        2

         假设现要编制一个满足下列要求的程序：对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数。由于上述计算过程是从低位到高位顺序产生八进制数的各个数位，而打印输出，一般来说应从高位到低位进行，恰好和计算过程相反。因此，若将计算过程中得到的八进制数的各位顺序进栈，则按出栈序列打印输出的即为与输入对应的八进制数。 这是利用栈后进先出特性的最简单例子。在这个例子中，栈操作的序列是直线式的，即先一味地入栈，然后一味地出栈。

#include<stdio.h>
#include <malloc.h>
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
//Status是函数的类型，其值是函数结果状态代码
typedef int Status;

#define STACK_INIT_SIZE 10
#define STACKINCREMENT 2

typedef struct{
	int *base;              //
	int *top;
	int stacksize;
}SqStack;
Status InitStack(SqStack *S)
{
	/* 构造一个空栈S */
	(*S).base = (int*)malloc(STACK_INIT_SIZE*sizeof(int));
	if(!(*S).base)
		exit(OVERFLOW);      /* 存储分配失败 */
	(*S).top = (*S).base;
	(*S).stacksize = STACK_INIT_SIZE;
	return OK;
}
Status DestroyStack(SqStack *S)
{
	/*销毁栈S,S不再存在*/
	free((*S).base);
	(*S).base = NULL;
	(*S).top = NULL;
	(*S).stacksize = 0;
	return OK;

}
Status ClearStack(SqStack *S)
{
	/* 把S置为空栈 */
	(*S).top = (*S).base;
	return OK;
}
Status StackEmpty(SqStack S)
{
/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
	if(S.top==S.base)
		return TRUE;
	else
		return FALSE;
}
int StackLength(SqStack S)
{
	/* 返回S的元素个数，即栈的长度 */
	return S.top-S.base;
}

Status GetTop(SqStack S,int *e)
{
	/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
	if(S.top>S.base)
	{
		*e = *(S.top-1);
		return OK;
	}
	else
		return ERROR;
}
Status Push(SqStack *S,int e)
{
	if((*S).top-(*S).base>=(*S).stacksize)/*栈满,追加存储空间*/
	{
		(*S).base = (int *)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(int));
		if(!(*S).base)
			exit(OVERFLOW);
		(*S).top = (*S).base + (*S).stacksize;
		(*S).stacksize += STACKINCREMENT;
	}
	*((*S).top)++=e;
	return OK;
}
Status Pop(SqStack *S,int *e)
{
	/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
   if((*S).top==(*S).base)
	   return ERROR;
   *e=*--(*S).top;
   return OK;
}
Status StackTraverse(SqStack S,Status (*visit)(int))
{
	/* 从栈底到栈顶依次对栈中每个元素调用函数visit()。 */
	/* 一旦visit()失败，则操作失败 */
	while(S.top>S.base)
		visit(*S.base++);
	printf("\n");
	return OK;
}
 void conversion() /* 算法3.1 */
 { /* 对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数 */
   SqStack s;
   unsigned n; /* 非负整数 */
   int e;
   InitStack(&s); /* 初始化栈 */
   printf("n(>=0)=");
   scanf("%u",&n); /* 输入非负十进制整数n */
   while(n) /* 当n不等于0 */
   {
     Push(&s,n%8); /* 入栈n除以8的余数(8进制的低位) */
     n=n/8;
   }
   while(!StackEmpty(s)) /* 当栈不空 */
   {
     Pop(&s,&e); /* 弹出栈顶元素且赋值给e */
     printf("%d",e); /* 输出e */
   }
   printf("\n");
 }
void main()
{
	conversion();
}
2、括号匹配的检验 

//括号匹配代码
#include<stdio.h>
#include <malloc.h>
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
//Status是函数的类型，其值是函数结果状态代码
typedef int Status;

#define STACK_INIT_SIZE 10
#define STACKINCREMENT 2

typedef struct{
	char *base;              //
	char *top;
	int stacksize;
}SqStack;
Status InitStack(SqStack *S)
{
	/* 构造一个空栈S */
	(*S).base = (char*)malloc(STACK_INIT_SIZE*sizeof(char));
	if(!(*S).base)
		exit(OVERFLOW);      /* 存储分配失败 */
	(*S).top = (*S).base;
	(*S).stacksize = STACK_INIT_SIZE;
	return OK;
}
Status DestroyStack(SqStack *S)
{
	/*销毁栈S,S不再存在*/
	free((*S).base);
	(*S).base = NULL;
	(*S).top = NULL;
	(*S).stacksize = 0;
	return OK;

}
Status ClearStack(SqStack *S)
{
	/* 把S置为空栈 */
	(*S).top = (*S).base;
	return OK;
}
Status StackEmpty(SqStack S)
{
/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
	if(S.top==S.base)
		return TRUE;
	else
		return FALSE;
}
int StackLength(SqStack S)
{
	/* 返回S的元素个数，即栈的长度 */
	return S.top-S.base;
}

Status GetTop(SqStack S,char *e)
{
	/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
	if(S.top>S.base)
	{
		*e = *(S.top-1);
		return OK;
	}
	else
		return ERROR;
}
Status Push(SqStack *S,char e)
{
	if((*S).top-(*S).base>=(*S).stacksize)/*栈满,追加存储空间*/
	{
		(*S).base = (char *)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(char));
		if(!(*S).base)
			exit(OVERFLOW);
		(*S).top = (*S).base + (*S).stacksize;
		(*S).stacksize += STACKINCREMENT;
	}
	*((*S).top)++=e;
	return OK;
}
Status Pop(SqStack *S,char *e)
{
	/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
   if((*S).top==(*S).base)
	   return ERROR;
   *e=*--(*S).top;
   return OK;
}
Status StackTraverse(SqStack S,Status (*visit)(char))
{
	/* 从栈底到栈顶依次对栈中每个元素调用函数visit()。 */
	/* 一旦visit()失败，则操作失败 */
	while(S.top>S.base)
		visit(*S.base++);
	printf("\n");
	return OK;
}
Status bracket_match() /* 算法3.1 */
 {
	 SqStack ss;
	 char input[16],*temp,c;
	 //char test[11];
	 InitStack(&ss);
	 gets(input);
	 temp = input;
	 while(*temp)
	 {
		 switch(*temp)
		 {
		 case '(':
		 case '[':Push(&ss,*temp++);
			      break;
		 case ')':
		 case ']':if(!StackEmpty(ss))
				  {
					  Pop(&ss,&c);
					  if(*temp == ')'&& c != '(' || *temp == ']' && c != '[')
					  {
						  printf("左右括号不配对\n");
						  exit(ERROR);
					  }
					  else
					  {
						  temp++;
						  break;
					  }
				  }
				  else
				  {
					  printf("缺乏左括号\n");
					  exit(ERROR);
				  }
		 default:temp++;
		 }
	 }
	 if(StackEmpty(ss))
			 printf("括号匹配\n");
		 else
			 printf("括号不匹配\n");
 }
void main()
{
	bracket_match();
}

3、表达式求值

 /* algo3-6.c 表达式求值（输入、输出和中间结果均只能是0～9） */
#include<stdio.h>
#include <malloc.h>
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
//Status是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef char SElemType;

#define STACK_INIT_SIZE 10
#define STACKINCREMENT 2

typedef struct{
	SElemType *base;              //
	SElemType *top;
	int stacksize;
}SqStack;
Status InitStack(SqStack *S)
{
	/* 构造一个空栈S */
	(*S).base = (SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
	if(!(*S).base)
		exit(OVERFLOW);      /* 存储分配失败 */
	(*S).top = (*S).base;
	(*S).stacksize = STACK_INIT_SIZE;
	return OK;
}
Status DestroyStack(SqStack *S)
{
	/*销毁栈S,S不再存在*/
	free((*S).base);
	(*S).base = NULL;
	(*S).top = NULL;
	(*S).stacksize = 0;
	return OK;

}
Status ClearStack(SqStack *S)
{
	/* 把S置为空栈 */
	(*S).top = (*S).base;
	return OK;
}
Status StackEmpty(SqStack S)
{
/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
	if(S.top==S.base)
		return TRUE;
	else
		return FALSE;
}
int StackLength(SqStack S)
{
	/* 返回S的元素个数，即栈的长度 */
	return S.top-S.base;
}

Status GetTop(SqStack S,SElemType *e)
{
	/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
	if(S.top>S.base)
	{
		*e = *(S.top-1);
		return OK;
	}
	else
		return ERROR;
}
Status Push(SqStack *S,SElemType e)
{
	if((*S).top-(*S).base>=(*S).stacksize)/*栈满,追加存储空间*/
	{
		(*S).base = (SElemType *)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));
		if(!(*S).base)
			exit(OVERFLOW);
		(*S).top = (*S).base + (*S).stacksize;
		(*S).stacksize += STACKINCREMENT;
	}
	*((*S).top)++=e;
	return OK;
}
Status Pop(SqStack *S,SElemType *e)
{
	/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
   if((*S).top==(*S).base)
	   return ERROR;
   *e=*--(*S).top;
   return OK;
}
Status StackTraverse(SqStack S,Status (*visit)(SElemType))
{
	/* 从栈底到栈顶依次对栈中每个元素调用函数visit()。 */
	/* 一旦visit()失败，则操作失败 */
	while(S.top>S.base)
		visit(*S.base++);
	printf("\n");
	return OK;
}

 SElemType Precede(SElemType t1,SElemType t2)
 { /* 根据教科书表3.1，判断两符号的优先关系 */
   SElemType f;
   switch(t2)
   {
     case '+':
     case '-':if(t1=='('||t1=='#')
                f='<';
              else
                f='>';
              break;
     case '*':
     case '/':if(t1=='*'||t1=='/'||t1==')')
                f='>';
              else
                f='<';
              break;
     case '(':if(t1==')')
              {
                printf("ERROR1\n");
                exit(ERROR);
              }
              else
                f='<';
              break;
     case ')':switch(t1)
              {
                case '(':f='=';
                         break;
                case '#':printf("ERROR2\n");
                         exit(ERROR);
                default: f='>';
              }
              break;
     case '#':switch(t1)
              {
                case '#':f='=';
                         break;
                case '(':printf("ERROR3\n");
                         exit(ERROR);
                default: f='>';
              }
   }
   return f;
 }

 Status In(SElemType c)
 { /* 判断c是否为运算符 */
   switch(c)
   {
     case'+':
     case'-':
     case'*':
     case'/':
     case'(':
     case')':
     case'#':return TRUE;
     default:return FALSE;
   }
 }

 SElemType Operate(SElemType a,SElemType theta,SElemType b)
 {
   SElemType c;
   a=a-48;
   b=b-48;
   switch(theta)
   {
     case'+':c=a+b+48;
             break;
     case'-':c=a-b+48;
             break;
     case'*':c=a*b+48;
             break;
     case'/':c=a/b+48;
   }
   return c;
 }

  SElemType EvaluateExpression() /* 算法3.4 */
 { /* 算术表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和运算数栈 */
   SqStack OPTR,OPND;
   SElemType a,b,c,x,theta;
   InitStack(&OPTR);
   Push(&OPTR,'#');
   InitStack(&OPND);
   c=getchar();
   GetTop(OPTR,&x);
   while(c!='#'||x!='#')
   {
     if(In(c)) /* 是7种运算符之一 */
       switch(Precede(x,c))
       {
         case'<':Push(&OPTR,c); /* 栈顶元素优先权低 */
                 c=getchar();
                 break;
         case'=':Pop(&OPTR,&x); /* 脱括号并接收下一字符 */
                 c=getchar();
                 break;
         case'>':Pop(&OPTR,&theta); /* 退栈并将运算结果入栈 */
		 Pop(&OPND,&b);
                 Pop(&OPND,&a);
                 Push(&OPND,Operate(a,theta,b));
                 break;
       }
     else if(c>='0'&&c<='9') /* c是操作数 */
     {
       Push(&OPND,c);
       c=getchar();
     }
     else /* c是非法字符 */
     {
       printf("ERROR4\n");
       exit(ERROR);
     }
     GetTop(OPTR,&x);
   }
   GetTop(OPND,&x);
   return x;
 }

 void main()
 {
   printf("请输入算术表达式（中间值及最终结果要在0～9之间），并以#结束\n");
   printf("%c\n",EvaluateExpression());
 }


以上内容文字部分摘自严蔚敏版《数据结构(C语言版)》，程序代码为本人整理，仅供个人学习使用，勿作它用。

路和前方
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
将非负十进制整数转化为八进制
06-02
将非负十进制整数转化为八进制
关于数据结构（四）
Joker700的博客
03-20 1132
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关
虚拟机栈的栈元素是什么？可以了解一下！
Stay Hungry,Stay Foolish
01-30 1461
JVM以方法作为最基本的执行单元，栈帧则是用于支持虚拟机进行方法调用与方法执行背后的数据结构，同样它也是JVM运行时数据区中的虚拟机栈的栈元素。
什么是栈：Python语言描述
bj_109的博客
09-30 1466
栈（stack）是一个项的有序集合，其中添加移除新项总发生在同一端。这一端通常称为“顶部”。与顶部对应的端称为“底部”。 就像图片所描述的，栈s=(a1,a2,…an-1,an)。最后入栈的是an，最先出栈的也是an。所以栈符合LIFO原则。 LIFO LIFO，即后进先出的排序原则。它基于在集合内的时间长度做排序。较新的项靠近顶部，较旧的项靠近底部。栈的底部很重要，因为在栈中靠近底部的项是存储...
栈和队列的基本概念
＃两个西柚
07-26 1835
栈和队列的基本概念 一、 栈的基本概念 1.栈的定义 栈是一种只能在一端进行插入或删除操作的线性表。其中允许进行插入或删除操作的一端称为栈顶(Top)。栈项由一个称为栈顶指针的位置指示器(其实就是一个变量，对于顺序栈，就是记录栈项元素所在数组位置标号的一个整型变量:对于链式栈，就是记录栈顶元素所在结点地址的指针)来指示，它是 动态变化的。表的另一端称为栈底，栈底是固定不变的。栈的插入和删除操作一般 称为入栈和出栈。 2.栈的特点 由栈的定义可以看出，栈的主要特点就是先进后出(FILO)。栈中的元素就好比开进
数据结构学习笔记.zip
12-30
数据结构学习资料分享 内容概览： 本次分享包涵了大学计算机相关专业必学的“数据结构”课程的一系列学习资料。主要包括： 算法代码：我们提供了多种数据结构的实现代码，包括数组、链表、栈、队列、树、图等。...
数据结构（C语言描述）学习笔记.zip
12-30
数据结构学习资料分享 内容概览： 本次分享包涵了大学计算机相关专业必学的“数据结构”课程的一系列学习资料。主要包括： 算法代码：我们提供了多种数据结构的实现代码，包括数组、链表、栈、队列、树、图等。...
小码哥《恋上数据结构与算法》学习笔记.zip
最新发布
12-30
数据结构学习资料分享 内容概览： 本次分享包涵了大学计算机相关专业必学的“数据结构”课程的一系列学习资料。主要包括： 算法代码：我们提供了多种数据结构的实现代码，包括数组、链表、栈、队列、树、图等。...
算法和数据结构体系学习班.zip
12-30
数据结构学习资料分享 内容概览： 本次分享包涵了大学计算机相关专业必学的“数据结构”课程的一系列学习资料。主要包括： 算法代码：我们提供了多种数据结构的实现代码，包括数组、链表、栈、队列、树、图等。...
数据结构-栈
qq_40368860的博客
11-21 325
1.什么是栈     栈 又称为堆栈或堆叠，栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈项，需要读数据的时候从栈页开始弹出数据(最后一个数据被第一个读出来)先进后出。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。       栈是允许在一端进行插入和删除操作的特殊线性表。允许进行插入和删除...
对于输入的任意一个非负十进制整数，打印输出与其等值的十六进制数
weixin_74015401的博客
05-16 596
【样例说明】先判断输入是否符合非负正整数要求,若输入不符合要求，提示:"输入错误,请重新输入:".【输出形式】输出相应十进制整数转换后的十六进制数，若输入不符合要求，提示错误，重新输入。【问题描述】对于输入的任意一个非负十进制整数，打印输出与其等值的十六进制数。【输入形式】非负十进制整数。
【数据结构 C描述】使用顺序栈编制一个满足下列要求的程序：对于输入的任意一个非负十进制数，打印输出与其等值的二进制数。
AlanLee97的博客
10-20 9766
【数据结构 C描述】使用顺序栈编制一个满足下列要求的程序：对于输入的任意一个非负十进制数，打印输出与其等值的二进制数。 //main.cpp #include &amp;lt;iostream&amp;gt; #include &amp;lt;malloc.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; #include &quot;SqStack.h&quot; using namespac
二. 栈和队列（待补充）
未来科学研究所
09-24 523
栈和队列——限定性的线性表结构 这两种数据结构是在程序设计中广泛使用的线性数据结构。 与线性表相比，栈和队列的插入和删除操作受到更多的限制。对比如下： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pymQCA2N-1632487846533)(C:\Polaris_LEARN\WORK-LEARNING\面经\数据结构\总结\栈和队列.assets\image-20210910230250101.png)] 线性表可以在任意位置进行插入或删除； 栈只能在栈顶进行插入和删除
对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数
u011831120的专栏
12-21 1万+
#include"stdio.h" #include"stdlib.h" #define OVERFLOW 0 #define OK 1 #define TRUE 1 #define FALSE 0 #define ERROR 0 #define STACK_INIT_SIZE 10 #define STACKINCREMENT 2 typedef int SElemType; typede
栈
houbin0912的博客
06-30 249
栈是数据结构中重要的线性结构，是一种特殊的线性表，只允许在表的一端进行插入或删除操作的线性表。表中允许进行插入、删除操作的一端称为栈顶，另一端称为栈底。栈项的当前位置是动态的，对栈顶当前位置的标记称为栈项指针。当栈中没有数据元素时，称为空栈。栈的插入操作称为进栈或入栈，栈的删除操作称为退栈或出栈。 上溢是当一个超长的数据进入到缓冲区时，超出部分被写入上级缓冲区，上级缓冲区存放的可能是数据、上
什么是栈？
热门推荐
程宇寒
05-08 7万+
什么是栈？ ps:文章来自于网络 当提及“栈”这个概念，很多初学者都会很迷茫。在C语言里，我们有一个内存区域叫做栈区。在单片机里，我们又常常听到一个操作叫做压栈。而在算法中，我们也有一个同名结构叫做栈。 我常常会问自己的学生“栈”这个字的意思到底是什么?大家想到的多是客栈。我们翻翻字典也不难发现，栈的第一个释义是：储存货物或供旅客住宿的房屋。所以客栈的想法并没有错，但是这也未免太过抽象。 ...
栈和队列实验：数制转换和括号匹配
m0_60284156的博客
10-08 1250
当计算机接受了第1个括号以后，它期待着与其匹配的第8个括号的出现，然而等来的却是第2个括号，此时第1个括号“[”只能暂时靠边，而迫切等待与第2个括号相匹配的第7个括号“）”的出现，类似的，因只等来了第3个括号“[”，此时，其期待的紧迫程度较第2个括号更紧迫，则第2个括号只能靠边，让位于第3个括号，显然第3个括号的期待紧迫程度高于第2个括号，而第2个括号的期待紧迫程度高于第1个括号；在接受了第4个括号之后，第3个括号的期待得到了满足，消解之后，第2个括号的期待匹配就成了最急迫的任务了，……
编程基于栈的操作实现将任意一个非负十进制数，打印输出与其等值的八进制数
m0_71912711的博客
03-25 2434
编程基于栈的操作实现将任意一个非负十进制数，打印输出与其等值的八进制数数据结构中编程基于栈的操作实现将任意一个非负十进制数，打印输出与其等值的八进制数。
基本结构——栈
菜鸟xk_110的博客
12-24 952
一. 什么是线性结构： 线性结构是一种有序数据项的集合，其中每个数据项都有唯一的前驱和后继（除了第一个没有前驱，最后一个没有后继），新的数据项加入到数据集中时，只会加入到原有某个数据项之前或之后，具有这种性质的数据集，就称为线性结构。 二. 栈（Stack）: 基本概念： 栈就是一种有次序的数据项集合，是一种线性结构。在栈中 ，数据项的加入和移除都仅发生在同一端，这一端叫栈“顶(top)”，另一端叫栈“底(base)”。 基本特点： 离栈底越近的数据项，留在栈中的时间就越长，而最新加入栈的数据项会被最先移
数据结构学习笔记c++
08-23
你好！关于学习数据结构的C语言笔记，我可以给你一些基本的指导和概念。数据结构是计算机科学中非常重要的一门课程，它涉及存储和组织数据的方法。C语言是一种常用的编程语言，很适合用于实现各种数据结构。 下面是一些数据结构的基本概念，你可以在学习笔记中包含它们： 1. 数组（Array）：一种线性数据结构，可以存储相同类型的元素。在C语言中，数组是通过索引访问的。 2. 链表（Linked List）：也是一种线性数据结构，但不需要连续的内存空间。链表由节点组成，每个节点包含数据和指向下一个节点的指针。 3. 栈（Stack）：一种后进先出（LIFO）的数据结构，类似于装满物品的箱子。在C语言中，可以使用数组或链表来实现栈。 4. 队列（Queue）：一种先进先出（FIFO）的数据结构，类似于排队等候的队伍。同样可以使用数组或链表来实现队列。 5. 树（Tree）：一种非线性数据结构，由节点和边组成。每个节点可以有多个子节点。二叉树是一种特殊的树结构，每个节点最多有两个子节点。 6. 图（Graph）：另一种非线性数据结构，由节点和边组成。图可以用来表示各种实际问题，如社交网络和地图。 这只是数据结构中的一些基本概念，还有其他更高级的数据结构，如堆、哈希表和二叉搜索树等。在学习笔记中，你可以介绍每个数据结构的定义、操作以及适合使用它们的场景。 希望这些信息对你有所帮助！如果你有任何进一步的问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值