数据结构day7

 链式栈

头文件

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_
#include<stdio.h>
#include<stdlib.h>

#define datatype int   //结点内数据类型

//链栈的结点
typedef struct StackNode
{
	union{
	datatype data;  //数据域
	int top;
	};
	struct StackNode *next; //指针域
}StackNode,*StackNodePtr;


//创建
StackNodePtr link_create();
//判空
int link_empty(StackNodePtr S);
//入栈
int link_push(StackNodePtr S,datatype e);
//出栈
int link_pop(StackNodePtr S);
//遍历
void link_show(StackNodePtr S);
//销毁
int link_free(StackNodePtr S);



#endif

源代码

#include"linkstack.h"


//创建
StackNodePtr link_create(){
	StackNodePtr S=(StackNodePtr)malloc(sizeof(StackNode));
	if(NULL==S){
		printf("创建失败\n");
		return NULL;

	}
	
	S->next=NULL;
	S->top=-1;
	printf("创建成功\n");
	return S;

}



//判空
int link_empty(StackNodePtr S){
	if(NULL!=S){
		return -1;
	}
	return S->next==NULL;
}



//入栈
int link_push(StackNodePtr S,datatype e){
	if(NULL==S){
		printf("不合法\n");
		return -1;
	}
	StackNodePtr p=(StackNodePtr)malloc(sizeof(StackNode));
	if(NULL==p){
		printf("不合法\n");
		return 0;
	}
	 p->data=e;
	 p->next=NULL;
	 p->next=S->next;
	 S->next=p;
	 S->top++;
	 printf("入栈成功\n");
	 return 1;
}



//出栈
int link_pop(StackNodePtr S){
		if(NULL==S||link_empty){
		printf("不合法\n");
		return -1;
	}
	StackNodePtr p=S->next;
	S->next=S->next->next;

	free(p);
	p->next=NULL;
	S->top--;
}




//遍历
void link_show(StackNodePtr S){
		if(NULL==S||link_empty){
		printf("不合法\n");
		return;
	}
	StackNodePtr p=S->next;
	while(p!=NULL){
		printf("%d\t",p->data);
		p=p->next;
	}
	puts("");
}



//销毁
int link_free(StackNodePtr S){
			if(NULL==S){
		printf("不合法\n");
		return -1;
	}
	StackNodePtr p=S->next;
	while(p!=NULL){
		link_pop(p);
		p=p->next;

	}
	free(S);
	S=NULL;
	return 1;

}

 

链式队

头文件

#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);

//出队
int list_pop(LinkQueuePtr LQ);

//销毁队伍
void list_free(LinkQueuePtr LQ);



#endif

源文件

#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   LQ->Tail  这两个是野指针
    //申请一个链表，将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(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)
    {
        printf("所给队列不合法\n");
        return 0;
    }

    //1、申请结点封装数据
    Node *p = (Node*)malloc(sizeof(Node));
    if(NULL==p)
    {
        printf("入队失败\n");
        return 0;
    }
    //将数据封装到结点中
    p->data = e;
    p->next = NULL;

    //2、将新结点连接到队尾指针指向的结点后面
    LQ->Tail->next = p;
    //3、更新尾指针
    LQ->Tail = p;

    //4、长度自增
    LQ->Head->len++;

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



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

    //1、标记要出队的结点
    Node * p = LQ->Head->next;

    //2、孤立要删除的结点
    LQ->Head->next = p->next;

    printf("%d出队成功\n", p->data);

    //3、释放要删除的结点
    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)
    {
        printf("释放失败\n");
        return ;
    }

    //1、释放整个链表
    while(!list_empty(LQ))
    {
        list_pop(LQ);
    }
    //释放头结点
    free(LQ->Head);
    LQ->Head = LQ->Tail = NULL;

    //2、释放队列
    free(LQ);
    LQ = NULL;

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

}