Day7 数据结构

目录

1、链栈

2、链式队列

思维导图

---

1、链栈

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_

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


typedef int datatype;
//创建链栈头结点
typedef struct Node
{
	union
	{
		datatype data;
	};
	struct Node *next;
}Node;


typedef struct 
{

	Node* top;
}Linkstack ,*LinkStackptr;

//创建链栈
LinkStackptr stack_create();

//申请节点封装数据
Node* node_buy(datatype e);

//入栈
int stack_insert_head(LinkStackptr LS,datatype e);

//出栈
int stack_delete_head(LinkStackptr LS);

//销毁栈
void stack_free(LinkStackptr LS);

//判空
int stack_empty(LinkStackptr LS);

//遍历栈
void stack_show(LinkStackptr LS);

#endif

#include"linkstack.h"



//创建栈
LinkStackptr stack_create()
{

	//申请栈的空间
	LinkStackptr LS = (LinkStackptr)malloc(sizeof(Linkstack));
	if(NULL==LS)
	{
		printf("创建失败\n");
		return NULL;
	}
	//申请一个Node节点类型的空间，给LS->top指向
	LS->top=(Node *)malloc(sizeof(Node));
	if(NULL==LS->top)
	{
		printf("链栈申请失败\n");
		return NULL;
	}
	//初始化
	LS->top->next=NULL;

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

}
//申请节点封装数据
Node* node_buy(datatype e)


{
    //在堆区申请结点
    Node *p = (Node *)malloc(sizeof(Node));
    if(NULL == p)
    {
        printf("结点申请失败\n");
        return NULL;
    }

    //结点申请成功，将数据封装进去
    p->data = e;
    p->next = NULL;

    return p;

}
//判空
int stack_empty(LinkStackptr LS)
{

	//判断逻辑
	if(NULL==LS||LS->top==NULL)
	{
	
		printf("所给栈不合法\n");
		return -1;
	}

	return LS->top->next == NULL;

}

//入栈
int stack_insert_head(LinkStackptr LS,datatype e)
{
	if(NULL==LS)
	{
		printf("所给栈不合法\n");
		return 0;
	}
	//调用封装函数存入数据
	Node *p = node_buy(e);
	//将新节点插在头指针之前
	p->next=LS->top;
	//将头指针上移
	LS->top=p;
	printf("入栈成功\n");
	return 1;
}

//出栈
int stack_delete_head(LinkStackptr LS)
{
	//判断逻辑
	if(NULL==LS)
	{
		printf("所给栈不合法\n");
		return -1;
	}
	//定义一个指针标记头指针的位置
	Node* q=LS->top;
	//孤立
	LS->top = q->next;
	//删除
	free(q);
	printf("出栈成功\n");

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

	printf("从栈顶到栈底的元素为:\n");
	//定义遍历指针从头指针的位置开始遍历
	Node *q = LS->top;
	while(q->next != NULL)
	{
		printf("%d\t",q->data);
		q = q->next;//后移
	}
	putchar(10);
	return ;
}

//释放栈
void stack_free(LinkStackptr LS)
{

	if(LS == NULL)
	{
		printf("释放失败\n");
		return ;
	}
	
	while(!stack_empty(LS))
	{
		stack_delete_head(LS);
	}
	free(LS->top);
	LS->top=NULL;
	free(LS);
	LS=NULL;
	printf("销毁成功\n");

}

#include"linkstack.h"


int main(int argc, const char *argv[])
{
	LinkStackptr LS=stack_create();
	if(NULL==LS)
	{
		return 0;

	}
	
	stack_insert_head(LS,7);
	stack_insert_head(LS,8);
	stack_insert_head(LS,5);
	stack_insert_head(LS,9);


	stack_free(LS);
	stack_show(LS);
	return 0;
}

2、链式队列

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

#include"linkqueue.h"
#include<stdio.h>
#include<stdlib.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;
}

//遍历队列
void list_show(LinkQueuePtr LQ)
{
	if(list_empty(LQ))
	{
		printf("所给队列不合法\n");
		return ;
	}
	Node *p=LQ->Head->next;
	while(p!=NULL)
	{
		printf("%d\t",p->data);
		p=p->next;
	}
	printf("\n");
	return ;
}

//入队
int list_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->data=e;
	p->next=NULL;
	LQ->Tail->next=p;
	LQ->Tail=p;
	LQ->Head->len++;
	printf("入队成功\n");
	return 1;
}

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

	if(LQ->Head->next==NULL)
	{
		LQ->Tail=LQ->Head;
	}
	return 1;
}

//销毁队伍
void list_free(LinkQueuePtr LQ)
{
	if(NULL==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");
	return ;
}

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

int main(int argc, const char *argv[])
{
	LinkQueuePtr LQ=list_create();	
	if(NULL==LQ)
	{
		printf("创建失败\n");
		return -1;
	}
	
	list_push(LQ,5);
	list_push(LQ,2);
	list_push(LQ,7);
	list_push(LQ,9);

	list_show(LQ);

	list_pop(LQ);
	list_pop(LQ);
	list_pop(LQ);
	list_pop(LQ);
	list_pop(LQ);

	list_free(LQ);

	return 0;
}

思维导图