Linux学习-数据结构（栈和队列）

1.栈和队列

1.概念

• 链表、栈和队列都是一种线性结构（一对一）
• 栈和队列是一种特殊的表状结构
• 栈只允许在栈顶位置入栈和出栈元素
• 链表可以在任意位置插入和删除元素
• 栈和队列只允许在指定位置插入和删除元素

2.栈

1.概念

• 先进后出，后进先出
• 栈顶：允许入栈和出栈的一段
• 栈底：不允许允许入栈和出栈的一段
• 入栈（压栈）：将元素放入栈顶位置
• 出栈（弹栈）：将栈顶元素取出
• 栈针：找出记录栈顶位置的标记

2.分类

顺序栈

• 增栈：栈的增长方向自低向高增长
• 减栈：栈的增长方向自高向低增长
• 空栈：栈针指向入栈的位置
• 满栈：栈针指向栈顶元素的位置

常见的顺序栈

1.空增栈

2.空减栈

3.满增栈

4.满减栈

顺序栈的实现

1.类型定义

#ifndef __SEQSTACK_H__
#define __SEQSTACK_H__typedef int datatype;typedef struck static{datatype *pdata;int top;int len;
}seqstack;#endif

2.创建顺序表

seqstack *creat_seqstack(int len)
{seqstack *ptmpstack = NULL;ptmpstack = malloc(sizeof(seqstack));if(ptmpstack == NULL){perror("fail to malloc");return NULL;}ptmpstack->pdata = malloc(sizeof(seqstack) * len);if(ptmpstack->pdata == NULL){perror("fail to malloc");return NULL;}ptmpstack->top = 0;ptmpstack->len = len;return ptmpstack;
}

3.顺序表的销毁

int destroy_seqstack(seqstack **pptmpstack)
{free((*pptmpstack)->pdata);free((*pptmpstack));*pptmpstack = NULL;return 0;
}

4.判断满栈、空栈

int Is_empty_seqstack(seqstack *ptmpstack)
{return ptmpstack->top == 0;
}int Is_full_seqstack(seqstack *ptmpstack)
{return ptmpstack->len == ptmpstack->top;
}

5.压栈和出栈

int entern_seqstack(seqstack *ptmpstack, datatype num)
{if(Is_full_seqstack(ptmpstack)){return -1;}ptmpstack->pdata[ptmpstack->top++] = num;return 0;
}datatype out_seqstack(seqstack *ptmpstack)
{if(Is_empty_seqstack(ptmpstack)){return -1;}return ptmpstack->pdata[--(ptmpstack->top)];
}

链式栈

• 使用链表的思想实现链式栈
• 参考单向链表定义类型

链式栈的实现

typedef int datatype;typedef struct node{datatype data;struct node *pnext;
}linknode;

/*创建空链式栈*/
linknode *creat_empty_linkstack(void)
{linknode *ptmpnode = NULL;ptmpnode = malloc(sizeof(linknode));if(ptmpnode == NULL){perror("fail to malloc");return NULL;}ptmpnode->pnext = NULL;return ptmpnode;
}/*判断是否为空栈*/
int is_empty_linkstack(linknode *phead)
{return phead->pnext == NULL;
}/*压栈*/
int push_linkstack(linknode *phead, datatype tmpdata)
{linknode *ptmpnode = NULL;ptmpnode = malloc(sizeof(linknode));if(ptmpnode == NULL){perror("fail to malloc");return -1;}ptmpnode->pnext = phead->pnext;ptmpnode->data = tmpdata;phead->pnext = ptmpnode;return 0;
}/*出栈*/
datatype out_linkstack(linknode *phead)
{linknode *pfreenode = NULL;datatype tmpdata;pfreenode = phead->pnext;tmpdata = pfreenode->data;phead->pnext = pfreenode->pnext;free(pfreenode);return tmpdata;
}/*销毁栈*/
int destroy_linkstack(linknode **pphead)
{linknode *pfreenode = NULL;linknode *ptmpnode = NULL;ptmpnode = pfreenode = *pphead;while(ptmpnode != NULL){ptmpnode = ptmpnode->pnext;free(pfreenode);pfreenode = ptmpnode;}*pphead = NULL;return 0;
}

3.队列

1.概念

• 先进先出，后进后出
• 队头：出队的一端
• 队尾：入队的一段
• 入队：将元素放入队列末尾
• 出队：将元素从队头中取出

2.分类

• 顺序队列
• 链式队列

顺序队列

typedef int datatype;typedef struct queue{datatype *pdata;int head;int tail;int len;
}seqqueue;

#include "seqqueuee.h"
#include <stdio.h>
#include <stdlib.h>/*创建队列*/
seqqueue *creat_seqqueue(int len)
{seqqueue *ptmpqueue = NULL;ptmpqueue = malloc(sizeof(seqqueue));if(ptmpqueue == NULL){perror("fail to malloc");return NULL;}ptmpqueue->pdata = malloc(sizeof(seqqueue) * len);if(ptmpqueue->pdata == NULL){perror("fail to malloc");return NULL;}ptmpqueue->head = 0;ptmpqueue->tail = 0;ptmpqueue->len = len;return ptmpqueue;
}/*销毁队列*/
int destroy_seqqueue(seqqueue **pptmpqueue)
{free((*pptmpqueue)->pdata);free(*pptmpqueue);*pptmpqueue = NULL;return 0;
}/*判断是否为满*/
/*为避免循环队列空与满的条件冲突，牺牲一个存放数据的空间，将tail+1 == head作
为判断队满的条件
循环队列如果head或者tail下标超过tlen范围，需要对tlen取余，保障head和tail的
值在队列下标范围内变化*/
int is_full_seqqueue(seqqueue *ptmpqueue)
{return ptmpqueue->head == (ptmpqueue->tail + 1) % (ptmpqueue->len);
}int is_empty_seqqueue(seqqueue *ptmpqueue)
{return ptmpqueue->tail == ptmpqueue->head;
}/*判断队列是否为空*/
int enturn_data_seqqueue(seqqueue *ptmpqueue, datatype tmpdata)
{if(is_full_seqqueue(ptmpqueue)){return -1;}ptmpqueue->pdata[ptmpqueue->tail] = tmpdata;ptmpqueue->tail = (ptmpqueue->tail + 1) % ptmpqueue->len;return 0;
}/*出队*/
datatype out_seqqueue(seqqueue *ptmpqueue)
{datatype tmpdata;if(is_empty_seqqueue(ptmpqueue)){return -1;}tmpdata = ptmpqueue->pdata[ptmpqueue->head];ptmpqueue->head = (ptmpqueue->head + 1) % ptmpqueue->len;return tmpdata;
}

链式队列

typedef int datatype;typedef struct queue{datatype data;struct queue *pnext;
}linkqueue;

/*创建空队列*/
linkqueue *creat_empty_linkqueue(void)
{linkqueue *ptmpqueue = NULL;ptmpqueue = malloc(sizeof(linkqueue));if(ptmpqueue == NULL){perror("fail to malloc");return NULL;}ptmpqueue->pnext = NULL;return ptmpqueue;
}/*销毁队列*/
int destroy_linkqueue(linkqueue **pphead)
{linkqueue *ptmpqueue = NULL;linkqueue *pfreequeue = NULL;ptmpqueue = pfreequeue = *pphead;while(ptmpqueue != NULL){ptmpqueue = ptmpqueue->pnext;free(pfreequeue);pfreequeue = ptmpqueue;}return 0;
}/*判断是否为空队列*/
int is_empty_linkqueue(linkqueue *phead)
{return phead->pnext == NULL;
}/*入队*/
int enter_linkqueue(linkqueue *phead, datatype tmpdata)
{linkqueue *ptmpqueue = NULL;linkqueue *pinsterqueue = NULL;pinsterqueue = malloc(sizeof(linkqueue));if(pinsterqueue == NULL){perror("fail to malloc");return -1;}ptmpqueue = phead;while(ptmpqueue->pnext != NULL){ptmpqueue = ptmpqueue->pnext;}pinsterqueue->data = tmpdata;pinsterqueue->pnext = ptmpqueue->pnext;ptmpqueue->pnext = pinsterqueue;return 0;
}/*出队*/
datatype out_linkqueue(linkqueue *phead)
{linkqueue *ptmpqueue = NULL;datatype tmpdata;if(is_empty_linkqueue(phead)){return -1;}ptmpqueue = phead->pnext;tmpdata = ptmpqueue->data;phead->pnext = ptmpqueue->pnext;free(ptmpqueue);return tmpdata;
}