栈与队列过程代码

如果需要基本内容理解可以看下我之前的文章对于栈，队列，线性表的理解

栈的顺序线性存储结构,让我们先对线性链表代码有个基本了解

将需要 的函数进行头文件包含

//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); 
 }

而队列其实就和栈的基本代码差不多就是他的指向需要改下，和它是先进先出。只需要将它的指向改下就好了。