23.08.09数据结构作业

最新推荐文章于 2024-07-23 21:38:06 发布

wdc857

最新推荐文章于 2024-07-23 21:38:06 发布

阅读量367

点赞数

文章标签：数据结构算法

本文链接：https://blog.csdn.net/wdc857/article/details/132197219

版权

链式栈

头文件

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX 8
typedef int datatype;

typedef struct Node
{
	union
	{
		datatype data;
		int top;
	};
	struct Node* next; //指针域

}Node,*LinkStack_Ptr;


//申请空间创建栈
LinkStack_Ptr stack_create();

//判空
int stack_empty(LinkStack_Ptr P);

//判满
int stack_full(LinkStack_Ptr P);

//入栈
int stack_push(LinkStack_Ptr P,datatype e);

//出栈
int stack_pop(LinkStack_Ptr P);

//遍历栈
void stack_show(LinkStack_Ptr P);

//获取栈顶元素
int stack_top_data(LinkStack_Ptr P);

//栈的大小
int stack_size(LinkStack_Ptr P);

//销毁栈
void stack_free(LinkStack_Ptr P);

#endif

源文件

#include "linkstack.h"


//申请空间创建栈
LinkStack_Ptr stack_create()
{
	LinkStack_Ptr P=(LinkStack_Ptr)malloc(sizeof(Node));
	if(NULL==P)
	{
		printf("链表不合法\n");
		return NULL;
	}
/*	P->data=(datatype *)malloc(sizeof(datatype));
	if(NULL==P->data)
	{
		printf("申请失败\n");
		free(P);
		return NULL;
	}*/

	//链表申请成功,进行初始化
	P->top=-1;
	P->next=NULL;
	//栈空间申请成功
	printf("栈空间申请成功\n");
	return P;
}

//判空
int stack_empty(LinkStack_Ptr P)
{
	if(NULL!=P)
	{
		return P->top==-1;
	}
	printf("链表不合法\n");
	return -1;
}

//判满
int stack_full(LinkStack_Ptr P)
{
	//判断逻辑
	if(NULL!=P)
	{
		return P->top==MAX-1;
	}
	printf("链表不合法\n");
	return -1;
}

//入栈
int stack_push(LinkStack_Ptr P,datatype e)
{
	//判断逻辑
	if(NULL==P||stack_full(P))
	{
		printf("链表不合法\n");
		return -1;
	}
	//申请空间
	LinkStack_Ptr q=(LinkStack_Ptr)malloc(sizeof(Node));
	if(NULL==q)
	{
		printf("申请失败\n");
		free(P);
		return -1;
	}
	//申请成功,给入栈元素初始化
	P->top++; //先加后压
	q->data=e; //将数据存放到栈中
	q->next=P->next;
	P->next=q;

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

}


//遍历栈
void stack_show(LinkStack_Ptr P)
{
	if(NULL==P||stack_empty(P))
	{
		printf("遍历失败\n");
		return ;
	}
	int num=P->top;
	Node* a =P->next;
	printf("从栈顶到栈底的元素分别是\n");
	while(num>=0)
	{
		printf("%d\t",a->data);
		a=a->next;
		num--;
	}
	putchar(10);
}


//出栈
int stack_pop(LinkStack_Ptr P)
{
	//判断逻辑
	if(NULL==P||stack_empty(P))
	{
		printf("出栈失败\n");
		return -1;
	}
	LinkStack_Ptr q=P->next;
	P->next=q->next;
	free(q);
	q=NULL;
	P->top--;
	printf("出栈成功\n");
	return 1;

}


//获取栈顶元素
int stack_top_data(LinkStack_Ptr P)
{
	//判断逻辑
	if(NULL==P||stack_empty(P))
	{
		printf("查找失败\n");
		return -1;
	}
	printf("栈顶元素为%d\n",P->next->data);
	return 1;
}


//栈的大小
int stack_size(LinkStack_Ptr P)
{
	//判断逻辑
	if(NULL==P||stack_empty(P))
	{
		printf("查找失败\n");
		return -1;
	}
	printf("栈的大小为%d\n",P->top+1);
	return 1;

}

//销毁栈
void stack_free(LinkStack_Ptr P)
{
	//判断逻辑
	if(NULL==P)
	{
		printf("释放失败\n");
		return ;
	}
	
	//结点全部销毁
	while(!stack_empty(P))
	{
		stack_pop(P);
	}
	
	free(P);
	P=NULL;
	printf("销毁成功\n");
	return ;
}

测试文件

#include "linkstack.h"
int main(int argc, const char *argv[])
{
	LinkStack_Ptr P=stack_create();
	if(NULL==P)
	{
		printf("链表不合法\n");
		return -1;
	}
	
	//入栈
	stack_push(P,1);
	stack_push(P,8);
	stack_push(P,4);
	stack_push(P,2);
	
	//遍历
	stack_show(P);
	
	stack_pop(P);
	stack_show(P);

	stack_top_data(P);

	stack_size(P);

	stack_free(P);
	P=NULL;

	stack_show(P);

	return 0;
}

链式队列

头文件

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_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 P);

//头删,出队
int list_del_pop(LinkQueuePtr P);

//遍历
void list_show(LinkQueuePtr P);

//尾插,入队
int list_insert_push(LinkQueuePtr P,datatype e);

//长度


//销毁
void list_free(LinkQueuePtr P);


#endif

源文件

#include "linkqueue.h"


//申请空间
LinkQueuePtr list_create()
{
	LinkQueuePtr P=(LinkQueuePtr)malloc(sizeof(LinkQueue));
	if(NULL==P)
	{
		printf("申请失败\n");
		return NULL;
	}
	P->Head=(Node*)malloc(sizeof(Node));
	if(NULL==P->Head)
	{
		printf("申请失败\n");
		return NULL;
	}
	P->Head->len=0;
	P->Head->next=NULL;
	P->Tail=P->Head;
	printf("申请成功\n");
	return P;
}

//判空
int list_empty(LinkQueuePtr P)
{
	if(NULL==P||NULL==P->Head)
	{
		printf("不合法\n");
		return -1;
	}
	return P->Head==P->Tail;
}

//头删
int list_del_pop(LinkQueuePtr P)
{
	if(NULL==P||list_empty(P))
	{
		printf("删除失败\n");
		return -1;
	}
	
	Node* q=P->Head->next;
	P->Head->next=q->next;
	P->Head->len--;
	free(q);
	q=NULL;
	printf("出队成功\n");
	if(P->Head->next==NULL)
	{
		P->Tail=P->Head;
	}
	return 1;

}

//遍历
void list_show(LinkQueuePtr P)
{
	if(NULL==P||list_empty(P))
	{
		printf("遍历失败\n");
		return ;
	}
	Node* a=P->Head->next;
	printf("队列的元素分别是:");
	while(a!=NULL)
	{
		printf("%d ",a->data);
		a=a->next;
	}
	putchar(10);

}

//尾插
int list_insert_push(LinkQueuePtr P,datatype e)
{
	if(NULL==P)
	{
		printf("所给队列不合法\n");
		return -1;
	}
	Node* q=(Node*)malloc(sizeof(Node));
	if(NULL==q)
	{
		printf("插入失败\n");
		return -1;
	}

	//插入成功
	q->data=e;
	q->next=NULL;
	P->Tail->next=q;
	P->Tail=q;
	P->Head->len++;
	printf("入队成功\n");

	return 1;

}


//销毁
void list_free(LinkQueuePtr P)
{
	if(NULL==P)
	{
		printf("销毁失败\n");
		return ;
	}
	while(!list_empty(P))
	{
		list_del_pop(P);
	}
	free(P->Head);
	P->Head=P->Tail=NULL;
	free(P);
	P=NULL;
	printf("销毁成功\n");
	return ;
}

测试文件

#include "linkqueue.h"
int main(int argc, const char *argv[])
{
	LinkQueuePtr P=list_create();
	if(NULL==P)
	{
		return -1;
	}
	list_insert_push(P,2);
	list_insert_push(P,4);
	list_insert_push(P,7);
	list_insert_push(P,9);
	list_show(P);
	list_del_pop(P);
	list_show(P);
	list_free(P);
	P=NULL;
	list_show(P);

	return 0;
}

思维导图