数据结构5

顺序栈

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

#define SIZE 10

typedef struct stack_node
{
	int stack_data[SIZE];

	int top;
}Stack;

enum ret_val{MALLOC_OK,MALLOC_NO,CREATE_OK,CREATE_NO,FULL_OK,FULL_NO,EMPTY_OK,EMPTY_NO,PUSH_OK,PUSH_NO,POP_OK,POP_NO};

int is_malloc_ok(Stack *stack)
{
	if(NULL == stack)
	{
		printf("malloc fail!\n");
	}

	else
	{
		return MALLOC_OK;
	}
}

int create_stack(Stack **stack)
{
	*stack = (Stack *)malloc(sizeof(Stack));

	if(MALLOC_OK == is_malloc_ok(*stack))
	{
		return CREATE_OK;
	}

	else
	{
		return CREATE_NO;
	}
}

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->stack_data[stack->top] = num;
		return PUSH_OK;
	}

	else
	{
		printf("Stack is full!\n");
		return PUSH_NO;
	}
}

int is_empty(Stack *stack)
{
	if(-1 == stack->top)
	{
		return EMPTY_OK;
	}

	return EMPTY_NO;
}

int pop_stack(Stack *stack)
{
	if(EMPTY_NO == is_empty(stack))
	{
		return stack->stack_data[stack->top--];
	}

	return POP_NO;
}




int main(int argc, const char *argv[])
{
	Stack * stack = NULL;

	create_stack(&stack);

	init_stack(stack);

	int i,num;

	for(i = 0; i < 15; i++)
	{
		if(PUSH_OK == push_stack(stack,i + 1))
		{
			printf("push stack success!\n");
		}

		else
		{
			printf("push stack fail!\n");
		}
	}

	for(i = 0; i < 15; i++)
	{
		num = pop_stack(stack);

		if(POP_NO != num)
		{
			printf("%d\n",num);
		}

		else
		{
			printf("pop stack fail!\n");
		}
	}


	return 0;
}

链栈

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

typedef struct node
{
	int num;
	char name[32];
	struct node *next;
}Node;

typedef struct stack_node
{
	int num;
	char name[32];
}Stack_node;

typedef  Node * Link;
typedef  Stack_node Stack;

enum ret_val{MALLOC_OK = 100,MALLOC_NO,CREATE_OK,CREATE_NO,EMPTY_OK,EMPTY_NO,PUSH_OK,PUSH_NO,POP_OK,POP_NO};


int is_malloc_ok(Link new_node)
{
	if(NULL == new_node)
	{
		printf("malloc fail!\n");
	}

	else
	{
		return MALLOC_OK;
	}
}

int create_node(Link *new_node)
{
	*new_node = (Link)malloc(sizeof(Node));

	if(MALLOC_OK == is_malloc_ok(*new_node))
	{
		return CREATE_OK;
	}

	else
	{
		return CREATE_NO;
	}
}

void create_stack(Link *stack)
{
	if(CREATE_NO == create_node(stack))
	{
		printf("creat stack fail!\n");
		return;
	}

	(*stack)->next = NULL;

}

int push_stack(Link stack,Stack node)
{
	Link new_node;
	int ret;

	ret = create_node(&new_node);

	if(ret == CREATE_NO)
	{
		printf("push error!\n");
	}

	else
	{
		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_empyt(Link stack)
{
	if(stack->next == NULL)
	{
		printf("The stack is empty!\n");
		return EMPTY_OK;
	}

	else
	{
		return EMPTY_NO;
	}
}

int pop_stack(Link stack,Stack *node)
{
	Link p = NULL;;

	p = stack->next;

	if(is_empyt(stack) == EMPTY_OK)
	{
		printf("The stack is empyt!\n");
		return POP_NO;
	}

	else
	{
		node->num = p->num;
		strcpy(node->name,p->name);

		stack->next = p->next;
		free(p);
		return POP_OK;
	}
}

int main()
{
	Link stack = NULL;
	Stack node;
	int i;
	int ret;

	create_stack(&stack);

	for(i = 0; i < 3; i++)
	{
		node.num = i + 1;
		scanf("%s",node.name);
		push_stack(stack,node);
	}

	for(i = 0; i < 3; i++)
	{
		ret = pop_stack(stack,&node);

		if(ret == POP_NO)
		{
			printf("pop fail\n");
		}
		else
		{
			printf("num = %d\n",node.num);
			printf("name is :%s\n",node.name);
		}
	}

	return 0;
}