<span style="font-size:24px;">一、栈是一种先进后出的数据结构,有两种方式进行实现:数组和链表。用数组实现,好处是不用指针操作,但是栈的大小是固定的,入栈是需要判断栈满,出栈时需要判断栈空。栈顶指针指向最后压入栈的数据(即每次入栈的时候我的栈顶指针先要+1,之后在进行压栈操作)。</span>
<span style="font-size:24px;">数据结构中应该体现数据(数组存储),栈顶(记录数组下标)。基本操作包括:初始化栈、判空、判满、压栈、出栈、清空栈、摧毁栈。用链表实现的好处是栈的大小可以扩展,不用提前声明。使用指针和链表形式,更为复杂。栈顶指针指向压入栈的最后数据。入栈的时候,动态申请一个链栈节点。数据结构中当定义链表中的节点,并且有指向该链表的栈顶指针和栈底指针。栈底一、栈是一种先进后出的数据结构,有两种方式进行实现:数组和链表。用数组实现,好处是不用指针操作,但是栈的大小是固定的,入栈是需要判断栈满,出栈时需要判断栈空。栈顶指针指向最后压入栈的数据(即每次入栈的时候我的栈顶指针先要+1,之后在进行压栈操作)。 数据结构中应该体现数据(数组存储),栈顶(记录数组下标)。基本操作包括:初始化栈、判空、判满、压栈、出栈、清空栈、摧毁栈。用链表实现的好处是栈的大小可以扩展,不用提前声明。使用指针和链表形式,更为复杂。栈顶指针指向压入栈的最后数据。入栈的时候,动态申请一个链栈节点。数据结构中当定义链表中的节点,并且有指向该链表的栈顶指针和栈底指针。栈底指针指向NULL(其实我觉得不用也行)。基本操作:初始化链栈、判空、压栈、出栈。二、实现代码指针指向NULL(其实我觉得不用也行)。基本操作:初始化链栈、判空、压栈、</span>
<span style="font-size:24px;">出栈。二、实现代码</span>
1、数组形式实现的栈</strong></span></p><p><span style="font-size:24px;"><strong></strong></span><pre name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
* init_stack
* in_stack
* out_stack
* full_stack
* empty_stack
* */
#define SIZE 4
struct stack{
int sta[SIZE];
int top;
};
void init_stack(struct stack * s)
{
memset(s->sta, 0, sizeof(s->sta));
s->top = -1;
}
int if_full(struct stack* s)
{
if(s->top == SIZE-1){
printf("stack is full. \n");
return -1;
}
else
return 0;
}
int in_stack(struct stack* s, int data)
{
if(!(if_full(s))){
(s->top)++;
s->sta[s->top] = data;
return 0;
}
else
return -1;
}
int if_empty(struct stack* s)
{
if(s->top == -1){
printf("stack if empty. \n");
return -1;
}
else
return 0;
}
int out_stack(struct stack * s)
{
if(!(if_empty(s))){
int tmp = s->sta[s->top];
(s->top)--;
return tmp;
}
else
return 0;
}
int main()
{
struct stack S;
init_stack(&S);
int data = 38;
#if 0
in_stack(&S, 10);
//in_stack(&S, 30);
//in_stack(&S, 20);
//in_stack(&S, 1);
int ret = in_stack(&S, 13);
if(ret < 0){
exit(1);
}
ret = out_stack(&S);
ret = out_stack(&S);
printf("ret: %d\n", ret);
ret = out_stack(&S);
if(ret == 0){
exit(1);
}
printf("ret: %d\n", ret);
#endif
return 0;
}
动态申请空间的数组栈
/*-------------2016.11.6--------------*/
/*----------public by 于全------------*/
/*-----------栈的操作----------------
* ---------1、创建栈-----------------
*----------2、释放栈-----------------
*----------3、清空栈----------------
*----------4、判空、判满------------
*----------5、压栈、出栈-----------
*----------6、取栈顶元素------------
*出现的问题:主函数 传递stack 为一个指针
需要二级指针接收才能修改内容。所以在creat函数里
定义一个stack,返回。--------------*/
#include <stdio.h>
#include <stdlib.h>
#define EmptyTOS -1
#define MinStackSize 2
typedef struct StackRecord
{
int Capacity;
int TopOfStack;
int *Array;
}StackRecord,*Stack;
//创建栈
Stack CreatStack (int);
//释放栈
void DestoryStack(Stack);
//判空
int IsEmpty(Stack);
//清空栈
void MakeEmpty(Stack);
//判满
int IsFull(Stack);
//压栈
void Push(int , Stack);
//打印栈
void ShowStack(Stack);
//弹出第一个数 取头元素
int Top(Stack);
//出栈
int Pop(Stack);
int main()
{
Stack stack;
stack = CreatStack(5);
Push(2,stack);
Push(3,stack);
Push(4,stack);
Push(5,stack);
ShowStack(stack);
Pop(stack);
ShowStack(stack);
}
Stack CreatStack(int MaxElements)
{
Stack stack;
if(MaxElements < MinStackSize)
{
printf("stack size is too small \n");
}
#if 1
stack = (Stack)malloc(sizeof(StackRecord));
if(stack ==NULL)
return ;
#endif
stack->Array = (int *)malloc(sizeof(int)*MaxElements);
if(stack->Array== NULL)
return ;
stack->Capacity = MaxElements;
stack->TopOfStack = -1;
return stack;
}
void DestoryStack(Stack stack)
{
if(stack != NULL)
{
free(stack->Array);
free(stack);
}
}
int IsEmpty(Stack stack)
{
return stack->TopOfStack == EmptyTOS;
}
void MakeEmpty(Stack stack)
{
stack->TopOfStack = EmptyTOS;
}
int IsFull(Stack stack)
{
if(stack->TopOfStack >= stack->Capacity)
{
return -1;
}
else
return 0;
}
void Push(int x,Stack stack)
{
if(IsFull(stack))
{
printf("stack is full . \n");
}
else
{
stack->TopOfStack++;
stack->Array[stack->TopOfStack] = x;
}
}
int Top(Stack stack)
{
if(IsEmpty(stack))
{
printf("stack is empty . \n");
return 0;
}
else
{
return stack->Array[stack->TopOfStack];
}
}
int Pop(Stack stack)
{
if(IsEmpty(stack))
{
printf("stack is empty \n");
return 0;
}
else
{
stack->TopOfStack--;
}
}
void ShowStack(Stack stack)
{
int i;
for(i = 0 ;i<=stack->TopOfStack;i++)
{
printf("%d",stack->Array[i]);
}
printf("\n");
}
2、链栈
#include <stdio.h>
#include <stdlib.h>
struct sta_node{
int data;
struct sta_node* next;
};
struct link_sta{
struct sta_node* top;
struct sta_node* buttom;
};
int init_link_sta(struct link_sta* ls)
{
ls->top = NULL;
ls->buttom = NULL;
}
void in_link_sta(struct link_sta* ls, int value)
{
struct sta_node* tmp = malloc(sizeof(struct sta_node));
tmp->data = value;
tmp->next = NULL;
if(ls->top == NULL){
ls->top = tmp;
tmp->next = ls->buttom;
}
else{
tmp->next = ls->top;
ls->top = tmp;
}
}
struct sta_node* if_empty(struct link_sta* ls)
{
if(ls->top == ls->buttom){
printf("stack is empty. \n");
return NULL;
}
}
struct sta_node* out_link_sta(struct link_sta* ls)
{
if(!(if_empty(ls)))
return NULL;
else {
struct sta_node* tmp = ls->top;
ls->top = (ls->top)->next;
tmp->next = NULL;
return tmp;
}
}
int main()
{
struct link_sta LS;
init_link_sta(&LS);
in_link_sta(&LS, 10);
in_link_sta(&LS, 12);
struct sta_node* value = out_link_sta(&LS);
// value = out_link_sta(&LS);
// value = out_link_sta(&LS);
// value = out_link_sta(&LS);
if(value == NULL){
exit(1);
}
printf("value: %d\n", value->data);
return 0;
}