小河学习日记--栈

栈：只有一个端口出入的数据结构
顺序：在一块连续的内存空间里存储元素与元素之间的关系
优点：速度快（随机访问），不易产生内存碎片，
缺点：内存要求高，添加删除不方便
非顺序（链式）：元素随机存储在内存空间中，元素之间建立（指针）构成关系。
优点：内存要求低，添加删除方便，
缺点：查找速度慢（只能从头逐个遍历），容易产生内存碎片

顺序栈：
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

typedef struct Stack
{
TYPE* arr; // 内存首地址
int len; // 栈的容量 typedef unsigned int size_t;
int top; // 栈顶下标
}Stack;

// 创建
Stack* creat_stack(size_t cal);
// 销毁
void destory_stack(Stack* stack);
// 入栈
bool push_stack(Stack* stack,TYPE data);
// 出栈
bool pop_stack(Stack* stack);
// 栈空
bool empty_stack(Stack* stack);
// 栈满
bool full_stack(Stack* stack);
// 栈顶
TYPE* top_stack(Stack* stack);

int main()
{
Stack* stack = creat_stack(15);
printf(“开始入栈：”);
for(int i=0; i<20; i++)
{
printf(“入栈%s，”,push_stack(stack,i)?“成功”:“失败”);
printf(“栈顶：%d\n”,*top_stack(stack));
}
printf("------------------------\n开始出栈：\n");
for(int i=0; i<15; i++)
{
printf(“栈顶：%2d，”,*top_stack(stack));
printf(“出栈：%s\n”,pop_stack(stack)?“成功”:“失败”);
}

}

// 创建
Stack* creat_stack(size_t cal)
{
Stack* stack = malloc(sizeof(Stack));
stack->arr = malloc(sizeof(TYPE)*cal);
stack->len = cal;
stack->top = -1;
return stack;
}

// 销毁
void destory_stack(Stack* stack)
{
free(stack->arr);
free(stack);
}

// 入栈
bool push_stack(Stack* stack,TYPE data)
{
if(full_stack(stack)) return false;
stack->arr[++stack->top] = data;
return true;
}

// 出栈
bool pop_stack(Stack* stack)
{
if(empty_stack(stack)) return false;
stack->top–;
return true;
}

// 栈空
bool empty_stack(Stack* stack)
{
return -1 == stack->top;
}

// 栈满
bool full_stack(Stack* stack)
{
return stack->top+1 >= stack->len;
}

// 栈顶
TYPE* top_stack(Stack* stack)
{
if(empty_stack(stack)) return NULL;
return stack->arr + stack->top;
}

链式栈：
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

typedef struct Node
{
TYPE data;
struct Node* next;
}Node;

Node* creat_node(TYPE data)
{
Node* node = malloc(sizeof(Node));
node->data = data;
node->next = NULL;
return node;
}

typedef struct Stack
{
Node* top;
size_t len;
}Stack;

// 创建
Stack* creat_stack(void);
// 销毁
void destory_stack(Stack* stack);
// 栈空
bool empty_stack(Stack* stack);
// 入栈
void push_stack(Stack* stack,TYPE data);
// 出栈
bool pop_stack(Stack* stack);
// 栈顶
TYPE* top_stack(Stack* stack);

int main()
{
Stack* stack = creat_stack();
for(int i=0; i<10; i++)
{
push_stack(stack,i);
printf(“top:%d\n”,*top_stack(stack));
}
printf("-----------------\n");
for(int i=0; i<10; i++)
{
printf(“top:%d,”,*top_stack(stack));
printf(“出栈%s\n”,pop_stack(stack)?“成功”:“失败”);
}
destory_stack(stack);
}

// 创建
Stack* creat_stack(void)
{
Stack* stack = malloc(sizeof(Stack));
stack->top = NULL;
stack->len = 0;
return stack;
}

// 销毁
void destory_stack(Stack* stack)
{
while(pop_stack(stack));
free(stack);
}

// 栈空
bool empty_stack(Stack* stack)
{
return NULL == stack->top;
}

// 入栈
void push_stack(Stack* stack,TYPE data)
{
Node* node = creat_node(data);
node->next = stack->top;
stack->top = node;
stack->len++;
}

// 出栈
bool pop_stack(Stack* stack)
{
if(empty_stack(stack)) return false;

Node* node = stack->top;//是top与node的地址相同
stack->top = node->next;
free(node);//删除地址释放内存
stack->len--;

return true;

}

// 栈顶
TYPE* top_stack(Stack* stack)
{
if(empty_stack(stack)) return NULL;

return &stack->top->data;

}