c语言堆栈笔记

堆栈：
特点：先进后出
FIRST IN LAST OUT
FILO
定以：是一种数据结构，该数据结构在存储数据的时候将先存入的数据存放到栈空间底部，取数据的时候从栈空间的顶部开始，是一种受限的线性表
栈顶: 数据存取的一端
栈底：数据存取对应的另一端
定义：
栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素

栈操作的实现：
栈操作的分类：
线性栈、链式栈
相关术语：
栈顶：允许进行插入和进行删除操作的一段成为栈顶
栈底：表的另一端称为栈底 （第一个元素进入的位置）
压栈(入栈、进栈)：在栈顶位置插入元素的操作叫做压栈，或入栈、进栈
出栈(弹栈、退栈)：删除栈顶元素的操作叫做出栈，也叫作弹栈，或者退栈
空栈：不含元素的空表
栈溢出：当栈满的时候，如果再有元素压栈，则发生上溢，当栈空的时候，再出栈则发生下溢

栈的实现方式：
可以用数据结构：链表（可连续或不连续的将数据与数据关联起来的结构），或 数组（连续的内存空间，按索引取值） 来实现 栈（stack)。
数组实现能快速随机访问存储的元素，通过下标 index 访问，支持随机访问，查询速度快，但存在元素在数组空间中大量移动的操作，增删效率低。
链表实现只支持顺序访问，在某些遍历操作中查询速度慢，但增删元素快。
栈操作：
1、初始化栈
2、入栈
3、出栈
4、栈空判断
5、访问栈顶元素
栈定义中只是说明栈操作属于先进后出的存储格式，并没有提及存储数据的类型
数组栈的实现：
通过数组实现栈操作
需要通过结构体实现，每个结构体被称为一个节点
数组栈的数据节点类型：

#define StackSize 1024 struct Stack{ int stacktop;//栈顶标记，初始值设置为-1，使得栈顶标记和数组的下标保持一致 DataType array[StackSize];//存放栈中数据的空间 }; ```

#include <stdio.h>
#include <stdlib.h>
#define StackSize 1024
typedef struct stack {
	int stacktop;//栈顶标记，初始值设置为-1，使得栈顶标记和数组的下标保持一致
	int *array;//存放栈中数据的空间
}Stack,*pStack;
//初始化栈
void InitStack(pStack s)
{
	s->stacktop = -1;
	s->array = (int *)malloc(StackSize*sizeof(int));
}
int isFull(pStack s)
{
	if (s->stacktop == StackSize - 1)
		return 1;
	else
		return 0;
}
int isEmpty(pStack s)
{
	if (s->stacktop == -1)
		return 1;
	else
		return 0;
}
void PushStack(pStack s,int num)
{
	if (isFull(s))
	{
		printf("栈满\n");
		return ;
	}
	s->array[++(s->stacktop)] = num;
}
int PopStack(pStack s)
{
	if (isEmpty(s))
	{
		printf("栈空\n");
		return 1;
	}
	 return s->array[s->stacktop--];
}

int OutputStackValue(pStack s)
{
	int inode = s->stacktop;
	if (isEmpty(s))
	{
		printf("栈空\n");
		return 1;
	}
	while (inode != -1)
	{
		printf("%d\n", s->array[inode]);
		inode--;
	}
	return 0;
}
int GetStackTop(pStack s)
{
	return s->array[s->stacktop];
}

int main()
{

	int i = 0,num=0,base=0;
	Stack s;
	InitStack(&s);
	printf("请输入一个十进制数和待转换的进制基数\n");
	scanf_s("%d%d", &num, &base);
	while (num)
	{
		PushStack(&s, num%base);
		num /= base;
	}
	OutputStackValue(&s);
	while (!isEmpty(&s))
	{
		printf("%d ", PopStack(&s));
	}
	printf("\n");
	/*
	for (i = 0; i < 5; i++)
	{
		PushStack(&s,i);
	}
	printf("%d\n",GetStackTop(&s));
	while (!isEmpty(&s))
	{
		printf("%d\n", PopStack(&s));
	}
	printf("%d\n", GetStackTop(&s));
	*/
	system("pause");
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#define StackSize 1024
#define TRUE 1
#define FALSE 0

typedef struct SqStack
{
	int  *base; /* 在栈构造之前和销毁之后，base的值为NULL */
	int  *top; /* 栈顶指针 */
	int  stacksize; /* 当前已分配的存储空间，以元素为单位 */
}Stack,*pStack;
//初始化栈
void InitStack(pStack s)
{
	s->base= (int *)malloc(StackSize * sizeof(int));
	s->top = s->base;
	s->stacksize = sizeof(int)*StackSize;
}
void DestroyStack(pStack s)
{
	free(s->base);
	s->base = NULL;
	s->top = NULL;
	s->stacksize = 0;
}
void ClearStack(pStack s)
{
	s->base = s->top;
}
int StackEmpty(pStack s)
{
	if (s->base == s->top)
		return TRUE;
	else
		return FALSE;
}
int StackLength(pStack s)
{
	return s->top - s->base ;
}
int GetTop(pStack s, int *value)
{
	//int *p = s->top;
	if (s->top > s->base)
	{
		//s->top--;
		//s->top -= 1;
		//s->top - 1;
		*value = *(s->top-1);
	}
	else if(s->top==s->base)
	{
		printf("栈空\n");
		return 1;
	}
	return *value;
}
void Push(pStack s, int value)
{
	if (s->top == s->base + s->stacksize)
	{
		printf("栈满\n");
		return;
	}
	else
	{
		*(s->top)++ = value;
		/**s->top = value;
		s->top++;*/
	}
	
}
int Pop(pStack s, int *value)
{
	if (s->top == s->base)
	{
		printf("栈空\n");
		return 1;
	}
	s->top--;
	*value = *s->top;
	return *value;
}
void visits (int value)
{
	printf("%d\n",value);
}
void StackTraverse(pStack s, void(*visit)(int))
{
	while (s->top > s->base)
	{
		visit(*s->base);
		s->base++;
	}
}
int main()
{
	Stack s;
	int i = 0,num=0;
	InitStack(&s);
	for (i = 0; i < 5; i++)
	{
		Push(&s, i);
	}
	printf("%d\n", GetTop(&s, &num));
	printf("%d\n", StackLength(&s));
	//StackTraverse(&s, visits);
	while (s.top > s.base)
	{
		printf("%d\n",Pop(&s, &num));
	}

	system("pause");
	return 0;
}

链式栈：

#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
typedef struct node {
	int data;
	struct node *next;
}Node,*pNode;
typedef struct SqStack
{
	pNode nod;
	int conut;
}Stack,*pStack;
pNode CreateLinkStack(pStack s)
{
	s->nod=(pNode)malloc(sizeof(Node));
	s->nod->data = 0;
	s->nod->next = NULL;
	s->conut = 0;
	return s->nod;
}
int isEmpty(pStack s)
{
	if (s->conut == 0)
		return 1;
	else
		return 0;
}
void Push(pStack s, int num)
{
	pNode newNode = (pNode)malloc(sizeof(Node));
	newNode->data = num;
	newNode->next = NULL;
	if (s->nod->next == NULL)
	{
		s->nod->next = newNode;
		newNode->next = NULL;
	}
	newNode->next = s->nod->next;
	s->nod->next = newNode;
	s->conut++;
}
pNode Pop(pStack s)
{
	return s->nod->next;
}
int getTop(pStack s)
{
	return s->nod->next->data;
}
void Print(pStack s)
{
	int i = 0;
	while (i < s->conut)
	{
		printf("%d\n", s->nod->next->data);
		s->nod = s->nod->next;
		i++;
	}
}
void ClearList(pStack s)
{
	int i = 0;
	pNode p = s->nod;
	while (i < s->conut)
	{
		p = s->nod;
		s->nod = s->nod->next;
		i++;
		free(p);
	}
	printf("ClearList success\n");
}

int main()
{
	Stack s;
	int i = 0;
	pNode pnode=CreateLinkStack(&s);
	for(i=0;i<5;i++)
	{
		Push(&s, i);
	}
	printf("%d\n", getTop(&s));
	Print(&s);
	while (s.conut!=0)
	{
		printf("%d\n",Pop(&s)->data);
		s.nod = s.nod->next;
		s.conut--;
	}
	ClearList(&s);
	system("pause");
	return 0;
}