八月九日作业

1、链队

头文件

#ifndef _FX_H_
#define _FX_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 queue_create();

//判空
int queue_empty(LinkQueuePtr LQ);

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

//遍历队
void queue_show(LinkQueuePtr LQ);

//出队
int queue_pop(LinkQueuePtr LQ);

//销毁队列
void queue_free(LinkQueuePtr LQ);




#endif

源文件

#include"fx.h"

//创建一个队列
LinkQueuePtr queue_create()
{
	//创建一个队列
	LinkQueuePtr LQ=(LinkQueuePtr)malloc(sizeof(LinkQueue));
	if(NULL==LQ)
	{
		printf("创建失败\n");
		return NULL;
	}
	
	//创建一个链表，将Head指针指向头结点
	LQ->Head=(Node*)malloc(sizeof(Node));
	if(NULL==LQ->Head)
	{
		printf("创建失败\n");
		return NULL;
	}

	//对头结点进行初始化
	LQ->Head->next=NULL;
	LQ->Head->len=0;

	//将尾指针指向头结点
	LQ->Tail=LQ->Head;
	printf("创建成功\n");
	return LQ;

}



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

	return LQ->Head==LQ->Tail;
}



//入队
int queue_push(LinkQueuePtr LQ,datatype e)
{
	if(NULL==LQ)
	{
		printf("入队失败\n");
		return 0;
	}

	//申请一个结点封装数据
	Node* P=(Node*)malloc(sizeof(Node));
	if(NULL==P)
	{
		printf("入队失败\n");
		return 0;
	}

	//对结点进行初始化
	P->next=NULL;
	P->data=e;

	//开始入队
	LQ->Tail->next=P;
	LQ->Tail=P;       //尾指针后移

	//队长变化
	LQ->Head->len++;
	printf("入队成功\n");
	return 1;
	                                                                                                                                                                           
}



//遍历队
void queue_show(LinkQueuePtr LQ)
{
	//判断逻辑
	if(NULL==LQ||queue_empty(LQ))
	{
		printf("遍历失败\n");
	}

	//定义一个遍历指针
	Node* q=LQ->Head->next;

	printf("从队头到队尾元素分别是: ");
	//开始遍历
	while(q!=NULL)
	{
		printf("%d\t",q->data);
		q=q->next;
	}
	putchar(10);
}



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

	//标记出队结点
	Node* P=LQ->Head->next;
	printf("%d出队成功\n",P->data);

	//孤立出队结点
	LQ->Head->next=P->next;

	//释放出队结点
	free(P);
	P=NULL;

	//队长变化
	LQ->Head->len--;
	
	//当链表为空时，尾指针重新指向头结点
	if(LQ->Head->next==NULL)
	{
		LQ->Tail=LQ->Head;
	}
	return 1;
}



//销毁队列
void queue_free(LinkQueuePtr LQ)
{
	//判断逻辑
	if(NULL==LQ)
	{
		printf("销毁失败\n");
	}

	//释放结点
	while(LQ->Head->next!=NULL)
	{
		queue_pop(LQ);
	}
	
	//释放头结点
	free(LQ->Head);
	LQ->Tail=LQ->Head=NULL;

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

测试文件

#include"fx.h"

int main(int argc, const char *argv[])
{
	//调用创建队列函数
	LinkQueuePtr LQ=queue_create();
	if(NULL==LQ)
	{
		return -1;
	}


	//调用入队函数
	queue_push(LQ,9);
	queue_push(LQ,5);
	queue_push(LQ,2);
	queue_push(LQ,7);
	queue_push(LQ,1);
	queue_push(LQ,3);
	queue_push(LQ,6);
	queue_push(LQ,4);
	
	//调用遍历函数
	queue_show(LQ);



	//调用出队函数
	queue_pop(LQ);
	queue_pop(LQ);
	queue_pop(LQ);
	queue_show(LQ);



	//调用销毁函数
	queue_free(LQ);
	LQ=NULL;
	
	return 0;
}

2、链栈

头文件

#ifndef _ZY_H_
#define _ZY_H_

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

typedef int datatype;

typedef struct Node
{
	union
	{
		datatype data;
		int len;
	};
	struct Node* next;
}LinkStack,*LinkStackPtr;


//创建栈
LinkStackPtr stack_create();

//判空
int stack_empty(LinkStackPtr S);

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

//遍历
void stack_show(LinkStackPtr S);

//出栈
int stack_pop(LinkStackPtr S);

//链栈的销毁
void stack_free(LinkListPtr S)




#endif

源文件

#include"zy.h"

//创建栈
LinkStackPtr stack_create()
{
	//创建栈
	LinkStackPtr S=(LinkStackPtr)malloc(sizeof(LinkStack));
	if(NULL==S)
	{
		printf("创建失败\n");
		return NULL;
	}

	//对头结点进行初始化
	S->len=0;
    S->next=NULL;

	printf("创建成功\n");
	return S;
}



//判空
int stack_empty(LinkStackPtr S)
{
	//判断逻辑
	if(NULL==S)
	{
		printf("所给链表不合法\n");
		return 0;
	}
	return S->next==NULL;
}




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

	//申请结点封装数据
	LinkStackPtr=(LinkStackPtr)malloc(sizeof(LinkStack));
	if(NULL==P)
	{
		printf("申请失败\n");
		return 0;
	}
	
	//对结点进行初始化
	P->data=e;
	P->next=NULL;

	//开始入栈
	P->next=L->next;
	S->next=P;
	S->len++;

	printf("入栈成功\n");
	return 1;
}



//遍历
void stack_show(LinkStackPtr S)
{
	//判断逻辑
	if(NULL==S||stack_empty(S))
	{
		printf("遍历失败\n");
	}

	//定义一个遍历指针
	LinkStackPtr q=S->next;

	//开始遍历
	printf("从栈顶到栈地元素分别为: ");
	while(q!=NULL);
	{
		printf("%d\t",q->data);
		q=q->next;
	}
		
}



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

	//删除逻辑
	LinkStackPtr P=S->next;
	S->next=P->next;
	free(P);
	P==NULL;

	//表长变化
	S->len--;
	printf("头删成功\n");
	return 1;
}



//链栈的销毁
void stack_free(LinkListPtr S)
{
	//判断逻辑
	if(NULL==S)
	{
		printf("释放失败\n");
	}

	//将所有结点全部释放
	while(!stack_empty(S))
	{
		stack_pop(S);
	}

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

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

测试文件

#include"zy.h"

int main(int argc, const char *argv[])
{
	//调用创建栈函数
	LinkStackPtr S=stack_create();
	if(NULL==S)
	{
		return 0;
	}



	//调用入栈函数
	stack_push(S,9);
	stack_push(S,5);
	stack_push(S,2);
	stack_push(S,7);
	stack_push(S,6);
	stack_push(S,4);
	stack_push(S,1);

	//调用遍历函数
	stack_show(S);


	//调用出栈函数
	stack_pop(S);
	stack_pop(S);
	stack_pop(S);
	stack_show(S);



	//调用销毁函数
	stack_free(S);
	S=NULL;
	
	return 0;
}