栈的基本概念及其顺序栈的基本运算

//main.cpp
#include"seqstack.h"
int main(void)
{
	int i = 0;

	int k = 0;

	int a[10] = { 1,2,3,4,5,6,7,8,9,10 };

	seqstack* stack = (seqstack*)malloc(sizeof(seqstack));//申请内存空间

	element* element_value= (element*)malloc(sizeof(element));//申请内存空间

	initseqstack(stack);//栈初始化

	for (i = 0; i <5; i++)
	{
		pushstack(stack,a+i);//入栈

		printf("当前入栈元素：%d\n", *(a + i));

	}

	printf("\n");

	for (i = 0; i <4; i++)
	{
		popstack(stack, element_value);//出栈

		printf("当前出栈元素：%d\n", element_value->ment[i]);

	}

	printf("\n");
	
	printf("当前栈内元素：%d\n", stack->stack[stack->top]);

    free(stack);//释放栈

	system("pause");

	return 0;

}
//seqstack.cpp
#include"seqstack.h"
/*
 * @file      seqstack.cpp
 * @function  栈初始化函数
 * @author    酸菜。
 * @date      2019-09-16
*/
int initseqstack(seqstack* stack)
{
	stack->length = 0;

	stack->top = -1;

	return 1;

}
/*
 * @file      seqstack.cpp
 * @function  入栈函数
 * @author    酸菜。
 * @date      2019-09-16
*/
int pushstack(seqstack* stack, int* value)
{
	if (stack->top == MAX - 1 || stack->length == MAX)
	{

		printf("栈以满，无法入栈：！\n");

		return 0;

	}
	stack->top++;

	stack->stack[stack->top]=*value;

	stack->length++;

	return 1;
}
/*
 * @file      seqstack.cpp
 * @function  出栈函数
 * @author    酸菜。
 * @date      2019-09-16
*/
int popstack(seqstack* stack, element* ment)
{
	static int p = 0;

	if (stack->top ==  - 1 || stack->length == 0)
	{

		printf("栈空，无法出栈：！\n");

		return 0;

	}	
	ment->ment[p++] = stack->stack[stack->top];

	stack->top--;

	stack->length--;

	return 1;
}
/*
 * @file      seqstack.cpp
 * @function  清空栈
 * @author    酸菜。
 * @date      2019-09-16
*/
void clear(seqstack* stack)
{
	stack->length = 0;

	stack->top = -1;
}
/*
 * @file      seqstack.cpp
 * @function  判断栈是否为空
 * @author    酸菜。
 * @date      2019-09-16
*/
int seqstack_is_empty(seqstack* stack)
{
	if (stack->top == -1 || stack->length == 0)
	{

		printf("栈空，无法出栈：！\n");

		return 1;

	}
	return 0;
}
/*
 * @file      seqstack.cpp
 * @function  判断栈是否满
 * @author    酸菜。
 * @date      2019-09-16
*/
int seqstack_is_full(seqstack* stack)
{
	if (stack->top == MAX-1 || stack->length == MAX)
	{

		printf("栈以满，无法入栈：！\n");

		return 1;

	}
	return 0;
}
/*
 * @file      seqstack.cpp
 * @function  获取栈顶元素
 * @author    酸菜。
 * @date      2019-09-16
*/
int getseqstack_value(seqstack* stack)
{

	return stack->stack[stack->top];

}

//seqstack.h
#ifndef   _seqstack_h
#define   _seqstack_h

#include<stdio.h>
#include<stdlib.h>
#include<iostream>

typedef int datatype;
#define MAX  100
typedef struct element
{
	datatype ment[MAX];
}element;
typedef struct seqstack
{
	datatype stack[MAX];//存放栈元素
	datatype top;//栈元素下标
	datatype length;//栈长度
}seqstack;

extern int initseqstack(seqstack* stack);//初始化栈
extern int pushstack(seqstack* stack, int* value);//进栈
extern int popstack(seqstack* stack ,element* ment);//出栈
extern void clear(seqstack* stack);//清空栈
extern int seqstack_is_empty(seqstack* stack);//判断栈是否空
extern int seqstack_is_full(seqstack* stack);//判断栈是否满
extern int getseqstack_value(seqstack* stack);//获取栈顶元素的值

#endif 

栈是线性表的特例，所以栈的顺序存储其实也是线性表顺序存储的简化，简称顺序栈。

那么我们是用数组的那一端作为栈底比较好呢？答案是下标为0的那一端。让它作为栈低。

栈的顺序存储结构还可以用以下结构：

#define  MAXSIZE  5

typedef int SElemTYpe;
typedef struct stack
{
  SElemTYpe data[MAXSIZE];//栈的大小
  int top;//栈顶指针
}seqstack;

这里top作为指示栈顶元素在数组中的位置，top可以来回移动，当栈中没有元素时，top等于-1，当然top也不可以超过栈的空间大小。
就像我们生活当中的游标卡尺一样，只能在一定的范围内来回移动。

//进栈

int push(seqstack* s,int value)
{
   if(s->top==MAXSIZE-1)
   {
      return 0;
  }

  s->top++;
  s->data[s->top]=value;

  return 1;
}

//出栈

int pop(seqstack* s)
{
   int i=0;
   if(s->top==-1)
   {
      return 0;
  }
  i=s->data[s->top];
  s->top--;
  return i;
}

无论是进栈还是出栈，两者没有涉及到任何循环语句，它们的时间复杂度均为O(1)。