2022/2/19

顺序实现堆栈

#include<stdio.h>
#include<stdlib.h>
#define SIZE 10
//差清空，读栈，置空
enum ret_val{FULL_OK,FULL_NO,EMPTY_OK,EMPTY_NO,PUSH_OK,PUSH_NO,POP_OK,POP_NO};

struct stack1
{
    int stack1_data[SIZE];
    int top;
};
typedef struct stack1 Stack;

void create_stack(Stack ** stack)//分配空间
{
    *stack=(Stack *)malloc(sizeof(Stack));
}

void init_stack(Stack *stack)//初始换
{
    stack->top=-1;
}
int is_full(Stack *stack)
{
    if (stack->top >= SIZE-1)
    {
        return FULL_OK;
    }
    return FULL_NO;
}
int push_stack(Stack *stack,int num)
{
    if (FULL_NO==is_full(stack))
    {
        stack->top++;
        stack->stack1_data[stack->top]=num;
        return PUSH_OK;
    }
    printf(" stack is full!\n");
    return PUSH_NO;
}
int is_empty(Stack *stack)
{
    if (stack->top == -1)
    {
        return EMPTY_OK;
    }
    return EMPTY_NO;
}
int pop_stcak(Stack *stack,int *p)
{
    if (EMPTY_NO == is_empty(stack))
    {
        *p=stack->stack1_data[stack->top];
        stack->top--;
        return POP_OK;
    }
    printf("stack is empty!\n");
    return POP_NO;
}
int main()
{
    Stack * stack=NULL;
    int i=0;
    int p;
    create_stack(&stack);

    init_stack(stack);
    for ( i = 0; i < 10; i++)
    {
        if(PUSH_OK == push_stack(stack,i+1))
        {
            printf("push  stack success!\n");
        }
        else
        {
            printf("push stack fail!\n");
        }    
    }
    for ( i = 0; i < 10; i++)
    {
        if (POP_OK == pop_stcak(stack,&p))
        {
            printf("%d\n",p);
            printf("pop stack success!\n");
        }
        else
        {
            printf("pop stack fial\n");
        }
    }
    
    free(stack);
    return 0;
}

链表实现堆栈

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct link_stack
{
    int num;
    char name[20];
    struct link_stack *next;
};
struct link_node
{
    int num;
    char name[20];
};

typedef struct link_stack *link;
typedef struct link_node  Node;
enum result{MALLOC_OK=
100,MALLOC_FAIL,EMPTY_OK,EMPTY_FAIL,PUSH_OK,PUSH_FAIL,POP_OK,POP_FAIL};

int create_node(link *new_node)
{
    *new_node=(link)malloc(sizeof(struct link_stack));
    if (*new_node==NULL)
    {
        printf("创建结点失败");
        return MALLOC_FAIL;
    }
    return MALLOC_OK;
}
void create_stack(link *stack)        //创建栈
{
    int ret;
    ret=create_node(stack);
    if (ret==MALLOC_FAIL)
    {
        printf("栈空间分配失败！\n");
        exit(-1);
    }
    (*stack)->next=NULL;
}

int push_stack(link stack,Node node)      //压栈
{
    link new_node;
    int ret;
    ret=create_node(&new_node);
    if (ret==MALLOC_FAIL)
    {
        printf("栈空间分配失败！\n");
        return PUSH_FAIL;
    }
    new_node->num=node.num;
    strcpy(new_node->name,node.name);
        
    new_node->next=stack->next;
    stack->next=new_node;

    return PUSH_OK;
}

int is_empty(link stack)
{
    if (stack->next=NULL)
    {
        printf("链表是空！\n");
        return EMPTY_OK;
    }
    return EMPTY_FAIL;
}

int pop_stack(link stack,Node *node)
{
    link new_node;
    new_node=stack->next;
    if (EMPTY_OK==is_empty(stack))
    {
        
        return POP_FAIL;
    }
    else
    {
    node->num=new_node->num;
    strcpy(node->name,new_node->name);  //赋值
    stack->next=new_node->next;            //出堆栈，头结点指向后面结点后释放
    free(new_node);
    return POP_OK;
    }
}
int main()
{
    link stack;
    Node node;
    int i;
    int ret;

    create_stack(&stack);
    for ( i = 0; i < 5; i++)
    {
        node.num=i+1;
        scanf("%s",node.name);
        push_stack(stack,node);
    }
    for (i = 0; i < 5; i++)
    {
        ret=pop_stack(stack,&node);
        if (ret == POP_FAIL)
        {
            printf("堆栈已经为空，无法输出\n");
        }
        else
        {
            printf("num=%d\n",node.num);
            printf("name is %s\n",node.name);
        }
    }
return 0;
}