day7数据结构

 

链式栈
linkstack.h
#ifndef __LINKSTACK_H__

#define __LINKSTACK_H__

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

typedef int datatype;

typedef struct Node

{
    union

    {
        int len;

        datatype data;

    };

    struct Node *next;    

}LinkStack,*LinkStackPtr;

//链式栈的创建

LinkStackPtr linkstack_create();

//判空

int linkstack_empty(LinkStackPtr LS);

//入栈

int linkstack_push(LinkStackPtr LS,datatype e);

//遍历栈

void linkstack_show(LinkStackPtr LS);

//出栈

int linkstack_pop(LinkStackPtr LS);

//释放栈

LinkStackPtr linkstack_free(LinkStackPtr LS);

#endif

 linkstack.c
#include "linkstack.h"

// 链式栈的创建

LinkStackPtr linkstack_create()

{
    LinkStackPtr LS = (LinkStackPtr)malloc(sizeof(LinkStack));

    if (NULL == LS)

    {
        printf("链式栈创建失败\n");

        return NULL;

    }

    LS->len = 0;

    LS->next = NULL;

    return LS;

}

// 判空

int linkstack_empty(LinkStackPtr LS)

{
    if (NULL == LS)

    {
        printf("创建的栈不合法\n");

        return -1;

    }

    return NULL == LS->next || 0 == LS->len;

}

// 入栈

int linkstack_push(LinkStackPtr LS, datatype e)

{
    if (NULL == LS)

    {
        printf("入栈失败\n");

        return 0;

    }

    LinkStackPtr p = (LinkStackPtr)malloc(sizeof(LinkStack));

    p->data=e;

    p->next = LS->next;

    LS->next = p;

    LS->len++;

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

    return 1;

}

// 遍历栈

void linkstack_show(LinkStackPtr LS)

{
    if (NULL == LS || linkstack_empty(LS))

    {
        printf("遍历失败\n");

        return;

    }

    LinkStackPtr q = LS;

    while (q->next!=NULL)

    {
        q = q->next;

        printf("%d\t", q->data);

    }

    putchar(10);

}

// 出栈

int linkstack_pop(LinkStackPtr LS)

{
    if (NULL == LS || linkstack_empty(LS))

    {
        printf("出栈失败\n");

        return 0;

    }

    LinkStackPtr q = LS->next;

    printf("%d已出栈\n", q->data);

    LS->next = q->next;

    free(q);

    q = NULL;

    LS->len--;

    return 1;

}

// 释放栈

LinkStackPtr linkstack_free(LinkStackPtr LS)

{
    if (NULL == LS)

    {
        printf("释放失败\n");

        return NULL;

    }

    LinkStackPtr q = LS->next;

    while (!linkstack_empty(LS))

    {
        linkstack_pop(LS);

    }

    free(LS);

    LS = NULL;

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

    return LS;

}

 main.c
#include "linkstack.h"

int main(int argc, char const *argv[])

{
    LinkStackPtr LS=linkstack_create();

    linkstack_push(LS,2);

    linkstack_push(LS,5);

    linkstack_push(LS,9);

    linkstack_push(LS,6);

    linkstack_show(LS);

    linkstack_pop(LS);

    linkstack_pop(LS);

    linkstack_show(LS);

    LS=linkstack_free(LS);

    return 0;

}

 链式队列
linkqueue.h

#ifndef __LINKQUEUE_H__

#define __LINKQUEUE_H__

#include <stdio.h>

#include <string.h>

#include <stdlib.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 linkqueue_create();

//判空

int linkqueue_empty(LinkQueuePtr LQ);

//入队

int linkqueue_push(LinkQueuePtr LQ,datatype e);

//出队

int linkqueue_pop(LinkQueuePtr LQ);

//遍历队列

void linkqueue_show(LinkQueuePtr LQ);

//销毁队列

LinkQueuePtr linkqueue_free(LinkQueuePtr LQ);

#endif

linkqueue.c

#include "linkqueue.h"

// 创建队列

LinkQueuePtr linkqueue_create()

{
    LinkQueuePtr LQ = (LinkQueuePtr)malloc(sizeof(LinkQueue));

    if (NULL == LQ)

    {
        printf("创建失败\n");

        return NULL;

    }

    LQ->Head = (Node *)malloc(sizeof(Node));

    if (NULL == LQ->Head)

    {
        free(LQ);

        printf("创建失败\n");

        return NULL;

    }

    LQ->Head->len = 0;

    LQ->Head->next = NULL;

    LQ->Tail = LQ->Head;

    printf("队列创建成功\n");

    return LQ;

}

// 判空

int linkqueue_empty(LinkQueuePtr LQ)

{
    if (NULL == LQ || NULL == LQ->Head)

    {
        printf("所给队列不合法\n");

        return -1;

    }

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

}

// 入队

int linkqueue_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 linkqueue_pop(LinkQueuePtr LQ)

{
    if (NULL == LQ || linkqueue_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 linkqueue_show(LinkQueuePtr LQ)

{
    if (NULL == LQ || linkqueue_empty(LQ))

    {
        printf("遍历失败\n");

        return;

    }

    Node *p = LQ->Head;

    while (p->next != NULL)

    {
        p = p->next;

        printf("%d\t", p->data);

    }

    putchar(10);

}

// 销毁队列

LinkQueuePtr linkqueue_free(LinkQueuePtr LQ)

{
    if (NULL == LQ )

    {
        printf("释放失败\n");

        return NULL;

    }

    while (!linkqueue_empty(LQ))

    {
        linkqueue_pop(LQ);

    }

    free(LQ->Head);

    LQ->Head = LQ->Tail = NULL;

    free(LQ);

    LQ = NULL;

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

    return LQ;

}

main.c

#include "linkqueue.h"

int main(int argc, char const *argv[])

{
    LinkQueuePtr LQ=linkqueue_create();

    if(NULL==LQ){
        return -1;

    }

    linkqueue_push(LQ,2);

    linkqueue_push(LQ,6);

    linkqueue_push(LQ,7);

    linkqueue_push(LQ,4);

    linkqueue_show(LQ);

    linkqueue_pop(LQ);

    linkqueue_pop(LQ);

    linkqueue_pop(LQ);

    linkqueue_pop(LQ);

    linkqueue_pop(LQ);

    linkqueue_pop(LQ);

    LQ=linkqueue_free(LQ);

    return 0;

}