如果需要基本内容理解可以看下我之前的文章对于栈,队列,线性表的理解
栈的顺序线性存储结构,让我们先对线性链表代码有个基本了解
将需要 的函数进行头文件包含
//seqlist.h
#include<stdio.h>
typedef void SeqList;
typedef void SeqListNode;
typedef struct tag_SeqList
{
int len;
int capacity;
unsigned int *node;
//int *node[] }TSeqList; //创建线性表
}
SeqList *SeqList_Create(int capacity);
//销毁线性表
void SeqList_Destroy(SeqList *list);
//清空链表
void SeqList_Clear(SeqList *list);
//链表长度
int SeqList_Length(SeqList *list);
//链表容量
int SeqList_Capacity(SeqList *list);
//将元素插入线性表
int SeqList_Insert(SeqList *list, SeqListNode *node, int position);
//获取线性表中某个位置的元素
SeqListNode *SeqList_Get(SeqList *list, int position);
//删除元素
SeqListNode* SeqList_Delete(SeqList *list, int position);
#include"seqlist.h" //创建链表
SeqList *SeqList_Create(int capacity)
{
int ret = 0;
TSeqList *tmp = NULL;
tmp = (TSeqList *)malloc(sizeof(TSeqList));
if (tmp == NULL) {
ret = -1;
//链表长度
int SeqList_Length(SeqList * list) {
TSeqList *tlist = NULL; if (list == NULL)
printf("func SeqList_Create() err : %d",ret);
return NULL;
}
memset(tmp, 0, sizeof(TSeqList));
//根据capacity分配节点空间
tmp->node = (unsigned int *)malloc(sizeof(unsigned int *)*capacity);
if (tmp->node == NULL)
{
ret = -2;
printf("func SeqList_Create() err : %d",ret);
return NULL;
}
tmp->capacity = capacity;
tmp->len = 0;
return tmp;
}//销毁链表
void SeqList_Destroy(SeqList * list)
{
TSeqList *tlist = NULL;
if (list == NULL)
{
return;
}
tlist = (TSeqList *)list;
if (tlist->node != NULL)
{
free(tlist->node);
} free(tlist);
}
//清空链表
void SeqList_Clear(SeqList * list)
{
TSeqList *tlist = NULL;
if (list == NULL)
{
return;
}
tlist = (TSeqList *)list;
tlist->len = 0;
}
{
return -1;
} tlist = (TSeqList *)list; return tlist->len;
}//链表容量
int SeqList_Capacity(SeqList *list)
{
TSeqList *tlist = NULL;
if (list == NULL)
{
return -1;
}
tlist = (TSeqList *)list;
return tlist->capacity;
}
//插入元素 !
int SeqList_Insert(SeqList *list, SeqListNode *node, int position)
{
int ret = 0; int i = 0; TSeqList *tlist = NULL; if (list == NULL || node == NULL || position < 0)
{
ret = -1;
printf("func SeqList_Create() err : %d",ret);
return ret;
}
tlist = (TSeqList *)list; //判断容量是否已满
if (tlist->capacity <= tlist->len)
{
ret = -2;
printf("func SeqList_Insert() err (tlist->capacity <= tlist->len) err : %d" ,ret);
return ret;
}
//容器修正,长度为6 容量20 用户插入位置为10
if (position >= tlist->len) {
position = tlist->len;
}
//元素后移
for (i = tlist->len; i > position; i--) {
tlist->node[i] = tlist->node[i - 1];//tlist->node[i]为最后一个元素的下一个位置
}
//插入元素
tlist->node[i] = (unsigned int)node; tlist->len++;
}
SeqListNode *SeqList_Get(SeqList *list, int position)
{
SeqListNode *ret = 0; TSeqList *tlist = NULL;
if (list == NULL || position < 0)
{
printf("func SeqList_Get() err : " );
return NULL;
}
tlist = (TSeqList *)list;
ret = (void *)tlist->node[position];
return ret;
}
//删除元素
SeqListNode* SeqList_Delete(SeqList * list, int position)
{
int i = 0;
SeqListNode *ret = 0;
TSeqList *tlist = NULL;
if (list == NULL || position < 0)
{
printf("func SeqList_Get() err : " );
return NULL;
}
tlist = (TSeqList *)list; ret = (void *)tlist->node[position];
//元素前移
for (i = position; i < tlist->len; i++) //从position位置后面的元素前移
{
tlist->node[i] = tlist->node[i + 1];
} tlist->len--; return ret;
//源文件
#include<stdio.h>
#include"seqlist.h"
struct student {
student(int i) {
age = i;
} int age;
};
void main()
{
SeqList *list = NULL;
student s1(10), s2(20), s3(30);
list = SeqList_Create(10);
SeqList_Capacity(list);
SeqList_Length(list);
SeqList_Insert(list, (SeqListNode *)&s1, 0);
//头插法
SeqList_Insert(list, (SeqListNode *)&s2, 0);
SeqList_Insert(list, (SeqListNode *)&s3, 0);
for (int i = 0; i < SeqList_Length(list); i++) {
student *tmp = (student *)SeqList_Get(list, i);
if (tmp == NULL) {
return;
} printf("student age: %d", tmp->age) ;
} printf("------------------"); //删除链表中的头节点
SeqList_Delete(list, 0); for (int i = 0; i < SeqList_Length(list); i++) {
student *tmp = (student *)SeqList_Get(list, i);
if (tmp == NULL) {
return;
} printf("student age: %d", tmp->age);
}
SeqList_Clear(list); //删除链表中的所有元素
而栈就和上面相同,其实栈就是个特殊的线性表
同样进行头文件包含
//seqstack.h
#include<stdio.h>
typedef void SeqStack;
//创建栈
SeqStack *SeqStack_Create(int capacity);
//销毁栈
void SeqStack_Destroy(SeqStack *stack);
//清空栈
void SeqStack_Clear(SeqStack *stack);
//进栈
int SeqStack_Push(SeqStack *stack,void *item);
//出栈
void *SeqStack_Pop(SeqStack *stack);
//获取栈顶元素
void *SeqStack_Top(SeqStack *stack);
//获取栈的大小
int SeqStack_Size(SeqStack *stack);
//获取栈的容量
int SeqStack_Capacity(SeqStack *stack);
//seqstack.c
#include<stdio.h>
#include"seqstack.h"
#include "seqlist.h"
//创建栈 相当于 创建线性表
SeqStack *SeqStack_Create(int capacity)
{
return SeqList_Create(capacity);
}
//销毁栈 相当于 销毁线性表
void SeqStack_Destroy(SeqStack *stack)
{
SeqList_Destroy(stack);
}
//清空栈 相当于 清空线性表
void SeqStack_Clear(SeqStack *stack)
{
SeqList_Clear(stack);
}
//压栈 相当于 从线性表的尾端插入元素
int SeqStack_Push(SeqStack *stack, void *item)
{
return SeqList_Insert(stack,item, SeqStack_Size(stack));
}
//出栈 相当于 从线性表的尾端取元素
void *SeqStack_Pop(SeqStack *stack)
{
return SeqList_Delete(stack, SeqStack_Size(stack)-1);
//注意元素从位置0开始
}
//获取栈顶元素 相当于 从线性表的尾端获取元素
void *SeqStack_Top(SeqStack *stack)
{
return SeqList_Get(stack, SeqStack_Size(stack) - 1);
}
//获取栈的大小 相当于 获取线性表的大小
int SeqStack_Size(SeqStack *stack)
{
return SeqList_Length(stack);
}
//获取栈的容量 相当于 获取线性表的容量 int SeqStack_Capacity(SeqStack *stack) {
return SeqList_Capacity(stack);
}
在主源文件进行
//test.c #include<stdio.h>
#include"seqstack.h"
void main()
{
SeqStack *stack = NULL;
int a[10];
stack = SeqStack_Create(10);
if (stack == NULL)
{
return;
}
for (int i = 0;i < 5;i++)
{ a[i] = i + 10;
SeqStack_Push(stack,&a[i]);
}
printf("stack size: %d",SeqStack_Size(stack));
printf("stack Capacity: %d" ,SeqStack_Capacity(stack));
while (SeqStack_Size(stack)>0)
{
int tmp= *(int *)SeqStack_Top(stack);
printf("%d",tmp);
SeqStack_Pop(stack);
}
printf("stack size: %d", SeqStack_Size(stack) );
SeqStack_Destroy(stack);
}
而队列其实就和栈的基本代码差不多就是他的指向需要改下,和它是先进先出。只需要将它的指向改下就好了。