链式队列和链式栈-优快云博客

本文链接：https://blog.youkuaiyun.com/Venusler/article/details/132196262

链式队列

头文件

#ifndef __HTLINKLIST_H__
#define __HTLINKLIST_H__

typedef int datatype;

typedef struct Node
{
	union
	{
		datatype data;
		int len;
	};

	struct Node *next;

}Node;

typedef struct
{
	Node *head;
	Node *tail;
}Linklist, *Linklistptr;

//创建一个空间
Linklistptr list_create();

//判断空
int list_empty(Linklistptr LQ);

//入队
int list_push(Linklistptr LQ,datatype e);

//遍历
int list_show(Linklistptr LQ);

//出队
int list_pop(Linklistptr LQ);

//尾删
int list_delete_tail(Linklistptr LQ);

//释放
void list_free(Linklistptr LQ);

#endif

源文件

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "htlinklist.h"

//创建一个头指针和尾指针
Linklistptr list_create()
{
	Linklistptr LQ=(Linklistptr)malloc(sizeof(Linklist));
	if(NULL==LQ)
	{
		printf("创建失败\n");
		return NULL;
	}

	//创建成功的话，说明里面有两个指针
	//申请一个链表将head指针指向头节点
	LQ->head=(Node*)malloc(sizeof(Node));
	if(NULL==LQ->head)
	{
		printf("创建失败\n");
		return NULL;
	}

	//成功需要将链表初始化
	LQ->head->len=0;
	LQ->head->next=NULL;

	//将尾指针指向头节点
	LQ->tail=LQ->head;

	printf("队列创建成功\n");
	return LQ;
}

//判断空
int list_empty(Linklistptr LQ)
{
	//判断逻辑
	if(NULL==LQ||NULL==LQ->head)
	{
		printf("所给队列不合法\n");
		return -1;
	}

	return LQ->head==LQ->tail;
}

//入队
int list_push(Linklistptr LQ,datatype e)
{
	//判断逻辑
	if(NULL==LQ||NULL==LQ->head)
	{
		printf("入队失败\n");
		return 0;
	}

	//申请一个节点封装数据
	Node *q=(Node *)malloc(sizeof(Node));
	if(NULL==q)
	{
		printf("申请失败\n");
		return -1;
	}

	q->data=e;
	q->next=NULL;

	//尾插过程
	q->next=LQ->tail->next;
	LQ->tail->next=q;

	//将尾指针指向q节点
	LQ->tail=q;

	printf("插入成功\n");

	//自增
	LQ->head->len++;

	return 1;
}

//遍历
int list_show(Linklistptr LQ)
{
	//判断逻辑
	if(NULL==LQ||list_empty(LQ))
	{
		printf("遍历失败\n");
		return 0;
	}

	//遍历过程
	Node *q=LQ->head;
	for(int i=1;i<=LQ->head->len;i++)
	{
		q=q->next;
		printf("元素分别是：");
		printf("%d\t",q->data);
	}
	putchar(10);
	return 1;
}

//出队
int list_pop(Linklistptr LQ)
{
	//判断逻辑
	if(NULL==LQ||list_empty(LQ))
	{
		printf("出队失败\n");
		return 0;
	}

	Node *q=LQ->head->next;
	//头删
	LQ->head->next=q->next;
	free(q);
	q=NULL;
	/*LQ->head->next=LQ->head->next->next;
	free(LQ->head->next);*/

	//自减
	LQ->head->len--;

	//判断队伍中是否已经删除完所有节点
	if(LQ->head->next==NULL)
	{
		//将尾指针重新指向头结点
		LQ->tail=LQ->head;
	}
	return 1;
}

//尾删
int list_delete_tail(Linklistptr LQ)
{	
	//判断逻辑
	if(NULL==LQ||list_empty(LQ))
	{
		printf("尾删失败\n");
		return 0;
	}

	//尾删过程
	free(LQ->tail);

	//自减
	LQ->head->len--;

	return 1;
}

//释放
void list_free(Linklistptr LQ)
{
	//判断逻辑
	if(NULL==LQ)
	{
		printf("释放失败\n");
		return ;
	}
	if(!list_empty(LQ))
	{
		list_pop(LQ);
	}

	//释放头节点
	free(LQ->head);
	LQ->head=LQ->tail=NULL;

	//释放队列
	free(LQ);
	LQ=NULL;
	printf("释放成功\n");
}

主函数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "htlinklist.h"
int main(int argc, const char *argv[])
{
	Linklistptr LQ=list_create();
	if(NULL==LQ)
	{
		return -1;
	}

	//入队
	list_push(LQ,1);
	list_push(LQ,2);
	list_push(LQ,1);
	list_push(LQ,3);
	list_push(LQ,8);

	//遍历
	list_show(LQ);

	//尾删
	//list_push(LQ);
	//printf("%d\n",LQ->head->len);
	//list_show(LQ);

	//出队
	list_pop(LQ);
	list_pop(LQ);
	list_pop(LQ);
	list_pop(LQ);
	list_pop(LQ);

	list_show(LQ);

	//释放
	list_free(LQ);

	return 0;
}

链式栈

头文件

#ifndef __LINKLISTZ_H__
#define __LINKLISTZ_H__

typedef int datatype;

typedef struct stack
{
	union
	{
		datatype data;  //数据
		int top;  //记录栈的栈顶
	};

	struct stack *next;  //指向下个节点的指针

}stack, *stackptr;

//创建一个空间
stackptr stack_create();

//判空
int stack_empty(stackptr S);

//入栈
int stack_push(stackptr S,datatype e);

//遍历
void stack_show(stackptr S);

//出栈
int stack_pop(stackptr S);

//获取栈顶元素并修改
int stack_top(stackptr S,datatype e);

//求栈的大小
int stack_size(stackptr S); 

//释放
void stack_free(stackptr S);

#endif

源文件

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linklistz.h"

//创建一个空间
stackptr stack_create()
{
	//从堆区创建一个空间
	stackptr S=(stackptr)malloc(sizeof(stack));
	if(NULL==S)
	{
		printf("该链表栈不合法\n");
		return NULL;
	}

	//初始化
	S->top=-1; //表长初始化
	S->next=NULL; //头结点初始化
	
	printf("链表栈创建成功\n");
	
	return S;
}

//判断空
int stack_empty(stackptr S)
{
	//判断逻辑
	if(NULL==S)
	{
		printf("判断空失败\n");
		return 0;
	}

	return S->top==-1; //表长为-1说明为空
}

//入栈
int stack_push(stackptr S,datatype e)
{
	//判断逻辑
	if(NULL==S)
	{
		printf("入栈失败\n");
		return 0;
	}

	//创建节点封装数据
	stackptr p=(stackptr)malloc(sizeof(stack));
	if(NULL==p)
	{
		printf("创建失败\n");
		return 0;
	}

	//节点初始化
	p->data=e;
	p->next=NULL;
	
	//先自增
	S->top++;
	
	//入栈（头插）
	//头插过程
	p->next=S->next;
	S->next=p;
	
	return 1;
}

//遍历
void stack_show(stackptr S)
{
	if(NULL==S||stack_empty(S))
	{
		printf("遍历失败\n");
		return ;
	}

	//遍历过程
	//定义一个指针指向头结点
	stackptr q=S;
	printf("从栈顶到栈底中的元素分别为：");
	for(int i=0;i<=S->top;i++)
	{
		q=q->next;
		printf("%d\t",q->data);
	}
	putchar(10);

	printf("遍历成功\n");
}

//出栈（头删）
int stack_pop(stackptr S)
{
	//判断逻辑
	if(NULL==S||stack_empty(S))
	{
		printf("出栈失败\n");
		return 0;
	}


	//定义一个指针指向第一个节点
	stackptr q=S->next;

	printf("%d出栈成功\n",q->data);
	
	//头删过程
	S->next=q->next;

	//释放第一个节点
	free(q);
	q->next=NULL; //置空，不然后面节点会出现随机值
	
	//自减
	S->top--;
	
	return 1;
}

//获取栈顶元素并修改
int stack_top(stackptr S,datatype e)
{
	//判断逻辑
	if(NULL==S||stack_empty(S))
	{
		printf("修改失败\n");
		return 0;
	}

	//修改过程

	//修改元素
	S->next->data=e;

	printf("修改成功\n");
	
	return 1;
}

//求栈的大小
int  stack_size(stackptr S)
{
	//判断逻辑
	if(NULL==S||stack_empty(S))
	{
		printf("求大小失败\n");
		return 0;
	}

	//求大小
	return S->top+1;
}
//释放
void stack_free(stackptr S)
{
	//判断逻辑
	if(NULL==S)
	{
		printf("释放失败\n");
		return ;
	}

	if(!stack_empty(S))
	{
		while(S->top!=-1)
		{
			stack_pop(S);
		}
	}

	//释放头结点
	free(S);
	S=NULL;

	printf("释放成功\n");
}

主函数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linklistz.h"
int main(int argc, const char *argv[])
{
	//调用创建空间函数
	stackptr S=stack_create();
	if(NULL==S)
	{
		return -1;
	}

	//入栈（先进去的后出，后进去的先出）
	stack_push(S,8);
	stack_push(S,3);
	stack_push(S,1);
	stack_push(S,2);
	stack_push(S,1);

	//遍历
	stack_show(S);

	//出栈
	stack_pop(S);
	stack_pop(S);
	stack_pop(S);

	stack_show(S);

	//获取栈顶元素并修改
	stack_top(S,7);
	
	stack_show(S);

	//求栈的大小
	printf("栈的大小为%d\n",stack_size(S));
	
	//释放
	stack_free(S);

	return 0;
}

思维导图