数据结构day7---8.9

链式队列：

1.头文件

#ifndef _lbdl_h_
#define _lbdl_h_
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int datatype;
typedef struct Node
{
    union
   {
      datatype data;
      int len;
   };
   struct Node *next;
}Node;

typedef struct
{
     Node * Head;            //记录队列的头部
     Node * Tail;            //记录队列的尾部
}LinkQueue, *LinkQueuePtr;

LinkQueuePtr list_create();//创建

int list_empty(LinkQueuePtr LQ);//判空

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

void list_show(LinkQueuePtr LQ);//遍历

int list_pop(LinkQueuePtr LQ);//出队

void list_free(LinkQueuePtr LQ);//释放队列

#endif

2.功能函数

#include"lbdl.h"

LinkQueuePtr list_create()//创建
{
	LinkQueuePtr LQ=(LinkQueuePtr)malloc(sizeof(LinkQueue));
	if(NULL==LQ)
	{
		printf("创建失败\n");
		return NULL;
	}
	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(LinkQueuePtr LQ)//判空
{
	if(NULL==LQ||NULL==LQ->Head)
	{
		printf("所给队列不合法\n");
		return -1;
	}
	return LQ->Head==LQ->Tail;
}

int list_push(LinkQueuePtr LQ,datatype e)//入队
{
	if(NULL==LQ||NULL==LQ->Head)
	{
		printf("入队失败\n");
		return 0;
	}
	Node *p=(Node *)malloc(sizeof(Node));
	if(NULL==p)
	{
		return 0;	
	}
	p->data=e;
	p->next=NULL;
	LQ->Tail->next=p;
	LQ->Tail=p;
	LQ->Head->len++;
	printf("入队成功\n");
	return 1;
}

void list_show(LinkQueuePtr LQ)//遍历
{
	if(NULL==LQ||NULL==LQ->Head||list_empty(LQ))
	{
		printf("遍历失败\n");
		return ;
	}
	Node *p=LQ->Head;
	printf("从输入的头到尾为：");
	int a=LQ->Head->len;
	for(int i=0;i<a;i++)
	{
		printf("%d\t",p->next->data);
		p=p->next;
	}
	putchar(10);
}

int list_pop(LinkQueuePtr LQ)//出队
{
	if(NULL==LQ||NULL==LQ->Head||list_empty(LQ))
	{
		printf("出队失败\n");
		return 0;
	}
	Node *p=LQ->Head->next;
	LQ->Head->next=p->next;
	printf("%d出队成功\n",p->data);
	free(p);
	p=NULL;
	LQ->Head->len--;
	if(LQ->Head->next==NULL)
	{
		LQ->Tail=LQ->Head;
	}
	return 1;
}

void list_free(LinkQueuePtr LQ)//释放队列
{
	if(NULL==LQ||NULL==LQ->Head||list_empty(LQ))
	{
		printf("释放失败\n");
		return ;
	}
	while(!list_empty(LQ))
	{
		list_pop(LQ);
	}
	free(LQ->Head);
	LQ->Head=LQ->Tail=NULL;
	free(LQ);
	LQ=NULL;
	printf("释放成功\n");
}

主函数

#include "lbdl.h"

int main(int argc, const char *argv[])
{
	LinkQueuePtr LQ=list_create();
	if(NULL==LQ)
	{
		return -1;
	}

	list_push(LQ,4);
	list_push(LQ,3);
	list_push(LQ,2);
	list_push(LQ,1);
	list_push(LQ,3);
	list_show(LQ);
	
	list_pop(LQ);
	list_pop(LQ);
	list_show(LQ);
	
	list_free(LQ);
	LQ=NULL;
	return 0;
}

链式栈：

 头文件

#ifndef _lz_h_
#define _lz_h_
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef int datatype;

typedef struct Stack
{
	union 
	{
		datatype data;     //指向堆区空间，用于存储栈的容器
		int top;     //记录栈顶元素的下标
	};
	struct Stack *next;
}Stack, *StackPtr;

StackPtr stack_create();//创建栈

int stack_empty(StackPtr L);//判空

int stack_push(StackPtr L,datatype e);//入栈

void stack_show(StackPtr L);//遍历栈

int stack_pop(StackPtr L);//出栈

datatype stack_top(StackPtr L);//获取栈顶元素

int stack_size(StackPtr L);//求栈的大小

void stack_free(StackPtr L);//销毁栈

#endif

功能函数

#include "lz.h"

StackPtr stack_create()//创建栈
{
	StackPtr L=(StackPtr)malloc(sizeof(Stack));
	if(NULL==L)
	{
		printf("栈申请失败\n");
		return NULL;
	}
	L->top=-1;
	L->next=NULL;
	printf("申请成功\n");
	return L;
}

int stack_empty(StackPtr L)//判空
{
	if(NULL!=L)
	{
		return L->top==-1;
	}
	printf("所给栈不合法\n");
	return -1;
}

int stack_push(StackPtr L,datatype e)//入栈
{
	if(NULL==L)
	{
		printf("入栈失败\n");
		return 0;
	}
	StackPtr p=(StackPtr)malloc(sizeof(Stack));
	if(NULL==p)
	{
		printf("节点申请失败\n");
		return 0;
	}
	p->data=e;
	p->next=NULL;
	L->top++;
	p->next=L->next;
	L->next=p;
	printf("入栈成功\n");
	return 1;
}

void stack_show(StackPtr L)//遍历栈
{
	if(NULL==L||stack_empty(L))
	{
		printf("遍历失败\n");
		return ;
	}
	StackPtr p=L->next;
	printf("从栈底到栈顶元素分别为：");
	for(int i=0;i<=L->top;i++)
	{
		printf("%d\t",p->data);
		p=p->next;
	}
	putchar(10);
}

int stack_pop(StackPtr L)//出栈
{
	if(NULL==L||stack_empty(L))
	{
		printf("出栈失败\n");
		return 0;
	}
	StackPtr p=L;
	while(p->next->next!=NULL)
	{
		p=p->next;
	}
	printf("%d出栈成功\n",p->next->data);
	p->next=NULL;
	free(p->next);
	p->next=NULL;
	L->top--;
	return 1;
}

datatype stack_top(StackPtr L)//获取栈顶元素
{
	if(NULL==L||stack_empty(L))
	{
		printf("获取失败\n");
		return 0;
	}
	StackPtr p=L;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	datatype e=p->data;
	return e;
}

int stack_size(StackPtr L)//求栈的大小
{
	if(NULL!=L)
	{
		return L->top+1;
	}
	printf("所给链表不合法\n");
	return -1;
}

void stack_free(StackPtr L)//销毁栈
{
	if(NULL==L)
	{
		printf("释放失败\n");
		return;
	}
	while(!stack_empty(L))
	{
		stack_pop(L);
	}
	free(L);
	L=NULL;
	printf("释放成功\n");
	return;

}

主函数

#include "lz.h"

int main(int argc, const char *argv[])
{
	StackPtr L=stack_create();
	if(NULL==L)
	{
		return -1;
	}

	stack_push(L,1);
	stack_push(L,2);
	stack_push(L,3);
	stack_push(L,4);
	stack_push(L,5);
	stack_push(L,6);

	stack_show(L);

	stack_pop(L);
	stack_pop(L);
	stack_pop(L);
	stack_show(L);

	datatype a=stack_top(L);
	printf("栈顶元素为：%d\n",a);
	
	int b=stack_size(L);
	printf("栈的大小为：%d\n",b);

	stack_free(L);
	L=NULL;
	stack_show(L);
	return 0;
}

思维导图：