7月27日，双向循环链表以及栈的一些东西

双向链表
没有逆序，只有排序；
代表头结点的循环链表；
代码

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

struct dnode
{
    int num;

    struct dnode * prior; //前驱
    struct dnode * next; //后继
};

typedef struct dnode Node;
typedef struct dnode* Link;

void is_malloc_ok(Link node)
{
    if(node == NULL)
    {
        printf("malloc error!\n");
        exit(-1);
    }
}

void create_node(Link *node) //创建结点
{
    *node = (Link)malloc(sizeof(Node));

    is_malloc_ok(*node);
}

void create_link(Link *head) //创建链表
{
    create_node(head); //创建表头结点

    (*head)->prior = (*head)->next = *head;
}

void insert_node_head(Link head,Link new_node) //头插
{
    new_node->prior = head;
    new_node->next = head->next;
    head->next = new_node;
    new_node->next->prior = new_node;
}

void display_link(Link head) //输出
{
    Link p;

    if(head == NULL)
    {
        printf("no such link!\n");
        return;
    }

    p = head->next;
    
    if(p == NULL)
    {
        printf("link is empty!\n");
        return;
    }

    while(p != head)
    {
        printf("%d\n",p->num);
        p = p->next;
    }
}

void insert_node_tail(Link head,Link new_node) //尾插
{
    new_node->next = head;
    new_node->prior = head->prior;
    head->prior = new_node;
    new_node->prior->next = new_node;
}

insert_node_midf(Link head,Link new_node,int loc) //中间插入前插
{
    Link p;

    p = head;

    while(p->next != head && p->num != loc)
    {
        p = p->next;
    }

    new_node->next = p;
    new_node->prior = p->prior;
    p->prior = new_node;
    new_node->prior->next = new_node;
}

insert_node_midl(Link head,Link new_node,int loc) //中间插入后插
{
    Link p;
    
    p = head;

    while(p->next != head && p->num != loc)
    {
        p = p->next;
    }

    new_node->prior = p;
    new_node->next = p->next;
    p->next = new_node;
    new_node->next->prior = new_node;
}

void release_node(Link head) //释放结点
{
    Link p;

    p = head->next;
    
    Link pr = NULL;

    while(p != head)
    {
        pr = p->next;
        p->next->prior = p->prior;
        p->prior->next = p->next;
        free(p);
        p = pr;
    }
}

void release_link(Link * head) //释放
{
    Link p;

    release_node(*head); //释放结点

    p = *head;
    (*head) = (*head)->next;
    free(p);

    *head = NULL;
}

void delete_node(Link head,int del) //删除结点
{
    Link p;

    p = head->next;

    while(p->num != del)
    {
        p = p->next;
    }
    p->next->prior = p->prior;
    p->prior->next = p->next;
    free(p);
}

int main()
{
    Link head = NULL;
    Link new_node = NULL;
    int i;

    create_link(&head); //创建链表

    for(i = 0;i < 10;i++)
    {
        create_node(&new_node);

        new_node->num = i + 1;
        
        //insert_node_head(head,new_node); //头插
        insert_node_tail(head,new_node); //尾插
    }

    display_link(head); //输出

    int loc;

    create_node(&new_node);
    printf("输入要插入的值：\n");
    scanf("%d",&new_node->num);
    printf("输入要插入的位置：\n");
    scanf("%d",&loc);

    //insert_node_midf(head,new_node,loc); //中间插入前插
    insert_node_midl(head,new_node,loc); //中间插入后插
    
    display_link(head);

    int del;

    printf("输入要删除的结点：\n");
    scanf("%d",&del);

    delete_node(head,del); //删除结点
    display_link(head);

    release_link(&head);

    display_link(head);

    return 0;
}

栈
定义：只允许在一端插入和删除的线性表；允许插入和删除的一端称为栈顶，另一端称为栈底。
特点：后进先出
代码：

#include <stdio.h>
#include <stdlib.h>
#define MAX 10
struct stack_data
{
    int stack[MAX];
    int top;
};

typedef struct stack_data Stack;

enum return_val{PUSH_OK=100,PUSH_NO,POP_OK,POP_NO,FULL_OK,FULL_NO,EMPTY_OK,EMPTY_NO};

void create_stack(Stack **stack) //创建栈
{
    *stack = (Stack *)malloc(sizeof(Stack));

    if(*stack == NULL)
    {
        printf("malloc error!\n");
        exit(-1);
    }
}

void init_stack(Stack * stack) //初始化
{
    stack->top = -1;
}

int is_full(Stack * stack) //判断栈满
{
    if(stack->top == MAX - 1)
    {
        return FULL_OK;
    }
    else
    {
        return FULL_NO;
    }
}

int push_stack(Stack * stack,int num) //进栈
{
    if(is_full(stack) == FULL_OK) //判断是否栈满
    {
        printf("stack is full!\n");
        return PUSH_NO;
    }
    else
    {
        stack->top++;
        stack->stack[stack->top] = num;
        return PUSH_OK;
    }
}

int is_empty(Stack * stack) //判断是否栈空
{
    if(stack->top == -1)
    {
        return EMPTY_OK;
    }
    else
    {
        return EMPTY_NO;
    }
}

int pop_stack(Stack * stack) //出栈
{
    if(is_empty(stack) == EMPTY_OK) //判断是否栈空
    {
        printf("stack is empty!\n");
        return POP_NO;
    }
    else
    {
        return stack->stack[stack->top--];
    }
}

int main()
{
    Stack * stack;
    int i;

    create_stack(&stack); //创建栈

    init_stack(stack); //初始化

    for(i = 0;i < 10;i++) //进栈
    {
        if(push_stack(stack,i + 1) == PUSH_OK) //判断进栈是否成功
        {
            printf("push ok!\n");
        }
        else
        {
            printf("push no!\n");
            break;
        }
    }

    int ret;

    for(i = 0;i < 10;i++) //出栈
    {
        ret = pop_stack(stack); //出栈
        
        if(ret == POP_NO) //判断出栈是否成功
        {
            printf("pop failure!\n");
            break;
        }
        else
        {
            printf("%d\n",ret);
        }
    }

    return 0;
}