栈作为一种
数据结构,是一种只能在一端进行插入和删除操作的特殊
线性表。它按照
先进后出的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶,需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)。栈具有记忆作用,对栈的插入与删除操作中,不需要改变栈底
指针。
栈是允许在同一端进行插入和删除操作的特殊
线性表。允许进行插入和删除操作的一端称为栈顶(top),另一端为栈底(bottom);栈底固定,而栈顶浮动;栈中元素个数为零时称为空栈。插入一般称为
进栈(PUSH),删除则称为退栈(POP)。栈也称为后进先出表。
顺序栈的实现
stack.h
#pragma once #define _CRT_SECURE_NO_WARN typedef int DataType; typedef struct Stack1 { DataType*top; size_t size; size_t capacity; }Stack; void IntiStack(Stack*ps, size_t capacity);//初始化 void PrintStack(Stack*ps);//打印 void PushStack(Stack*ps, DataType data);//入栈 void PopStack(Stack*ps);//出栈 DataType TopStack(Stack*ps);//取栈顶元素 size_t SizeStack(Stack*ps);//获取栈的大小 int EmptyStack(Stack*ps);//判空 void DestroyStack(Stack*ps);//销毁栈
stack.c
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<Windows.h> #include<assert.h> #include"Stack.h" void IntiStack(Stack*ps, size_t capacity) { assert(ps&&capacity>0); ps->top = (DataType*)malloc(sizeof(DataType)*capacity); assert(ps->top); ps->size = 0; ps->capacity = capacity; } void PrintStack(Stack*ps) { assert(ps); while (EmptyStack(ps) != 0) { printf("%d \n", TopStack(ps)); PopStack(ps); } } void PushStack(Stack*ps, DataType data) { assert(ps); if (ps->capacity == ps->size) { ps->capacity *= 2; ps->top = (DataType*)realloc(ps->top, sizeof(DataType)*ps->capacity); } ps->top[ps->size++] = data; } void PopStack(Stack*ps) { assert(ps&&ps->size); --ps->size; } DataType TopStack(Stack*ps) { assert(ps&&ps->size); return ps->top[(ps->size) - 1]; } size_t SizeStack(Stack*ps) { assert(ps); return (ps->size); } int EmptyStack(Stack*ps) { assert(ps); return (ps->size); } void DestroyStack(Stack*ps) { assert(ps); ps->capacity = 0; ps->size = 0; free(ps->top); ps = NULL; }
test.c
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include"Stack.h" #include<Windows.h> test() { Stack _stack; IntiStack(&_stack,10); PushStack(&_stack, 1); PushStack(&_stack, 2); PushStack(&_stack, 3); PushStack(&_stack, 4); PrintStack(&_stack); printf("%d",SizeStack(&_stack)); } int main() { test(); system("pause"); return 0; }
链式栈的基本操作:
stack.h
#pragma once #define _CRT_SECURE_NO_WARNING1 typedef int DataType; typedef struct Node { DataType data; struct Node* _next; }Node; Node*BuyNode(DataType value);//创建一个节点 void InitStack(Node**p);//初始化 Node* PushBackStack(Node**p, DataType value);//入栈 void PopBackStack(Node**p);//出栈 Node*TopStack(Node**p);//取栈顶元素 void PrintStack(Node**p);//打印 size_t GetSizeStack(Node**p);//取栈大小
stack.c
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<Windows.h> #include<assert.h> #include"Stack.h" Node*BuyNode(DataType value) { Node*pNewNode = (Node*)malloc(sizeof(Node)); if (pNewNode != NULL) { pNewNode->data = value; pNewNode->_next = NULL; return pNewNode; } return -1; } void IntiStack(Node**p) { assert(p); *p = NULL; } Node* PushBackStack(Node**p,DataType value) { assert(p); if (*p == NULL)//第一次进栈 { *p = BuyNode(value); return *p; } Node* pCur = *p; while (pCur->_next!= NULL) { pCur = pCur->_next; } Node*pNewNode = BuyNode(value); pCur->_next = pNewNode; return pNewNode; } void PopBackStack(Node**p) { assert(p); Node*pCur = *p; Node*pPrev = NULL; while (pCur->_next != NULL) { pPrev = pCur; (pCur) = pCur->_next; } free(pCur); if (pPrev != NULL) { pPrev->_next = NULL; } } Node*TopStack(Node**p) { assert(p); Node*pCur = *p; while (pCur->_next != NULL) { pCur = pCur->_next; } return pCur; } size_t GetSizeStack(Node**p) { assert(p); size_t count = 0; Node*pCur = *p; while (pCur!= NULL) { count++; pCur = pCur->_next; } return count; } void PrintStack(Node**p) { assert(p); Node*pCur = TopStack(p); int count = GetSizeStack(p); while (count>1) { Node*pCur = TopStack(p); printf("%d\n", pCur->data); PopBackStack(p); count--; } printf("%d\n", TopStack(p)->data); }
test.c
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include"Stack.h" #include<Windows.h> test() { Node* Node; IntiStack(&Node); PushBackStack(&Node, 1); PushBackStack(&Node, 2); PushBackStack(&Node, 3); PushBackStack(&Node, 4); //PopBackStack(&Node); PrintStack(&Node); } int main() { test(); system("pause"); return 0; }