实验三的八进制数

typedef int ElemType;

#include<stdio.h>    //基本输入输出功能 
#include<malloc.h>   //分配内存空间功能 
#include<string.h>   //memset函数的头文件
#include<stdlib.h>   //随机时间种子使用 
#include<time.h>	 //随机时间种子使用 

#define LINE_DATA_NUMS 10 //输出结果时，每行最多数据个数 

#define MEM_ALLOC_FAIL -2  //内存初始化分配失败 
#define MEM_Add_ALLOC_FAIL -6  //新增空间内存分配失败 

//线性表常量
#define LIST_INIT_SIZE 10
#define LIST_INCRE_SIZE 5
#define LIST_NOT_EXISTS -1
#define LIST_EMPTY -3
#define POS_INVALID - 4

//队列常量 
#define QUEUE_NOT_EXISTS -1
#define QUEUE_EMPTY -3
#define QUEUE_NO_SPACE -4  //顺序循环队列存储空间不足，当插入数据速度超过删除数据速度时 
#define MAX_QSIZE 100 //顺序循环队列参数：最大空间 

//栈常量
#define STACK_INIT_SIZE 10
#define STACK_INCRE_SIZE 5 
#define STACK_NOT_EXISTS -1
#define STACK_EMPTY -3

//包含min，但不包含max 





/*
int main()
{
	PokerColor pc;
	pc = (PokerColor)0;
	
	printf("%d",pc);
	
	return 0;
}*/
typedef struct {
	ElemType *top;
	ElemType *base; 
	int size;
}SqStack;

int InitStack(SqStack *S);
int ClearStack(SqStack *S);
int DestroyStack(SqStack *S);
int StackEmpty(SqStack S);
int StackLength(SqStack S);
int Push(SqStack *S,ElemType elem);
int Pop(SqStack *S,ElemType *elem);
int GetSTop(SqStack S,ElemType *elem);
void Output(ElemType elem);
int STraverse(SqStack S,void (*visit)(ElemType elem));

int InitStack(SqStack *S)
{
	//1 申请栈空间 
	ElemType *p = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
	
	//2 内存空间分配失败，则返回-2 
	if(p == NULL)
	{
		return MEM_ALLOC_FAIL;
	}
	
	//3 内存分配成功，则设置头节点指针域 
	S->top = p;
	S->base = p;
	S->size = STACK_INIT_SIZE;	

	return 0;
}

int Push(SqStack *S,ElemType elem)
{
	//1 栈不存在 
	if(S->base == NULL)
	{
		return 	STACK_NOT_EXISTS;
	} 
		
	//2 写入数据前，空间判断
	if((S->top - S->base) == S->size)
	{
		ElemType *p = (ElemType *)realloc(S->base,(S->size + STACK_INCRE_SIZE)* sizeof(ElemType));
		
		if(p == NULL)
		{
			return MEM_Add_ALLOC_FAIL;
		}
		
		S->base = p;
		S->size += STACK_INCRE_SIZE;		
	} 
		
	//3 内存分配成功,写入数据 
	*(S->top) = elem;		
	S->top += 1;
		
	return 0;	
}

int Pop(SqStack *S,ElemType *elem)
{		
	//1 若栈不存在 
	if(S->base == NULL)
	{
		return STACK_NOT_EXISTS;
	}
	//2 空栈 
	if(S->top - S->base == 0)
	{
		return STACK_EMPTY;
	}
	
	//3 出栈
	S->top -= 1; 
	*elem = *(S->top) ;		
	
	return 0;
}

int ClearStack(SqStack *S)
{
	if(S->base == NULL)
	{
		return STACK_NOT_EXISTS; //栈不存在	
	}
		
	S->top = S->base;
	
	return 0;
}

int DestroyStack(SqStack *S)
{
	if(S->base == NULL)
	{
		return STACK_NOT_EXISTS;  //栈不存在	
	} 
			
	free(S->base);
	
	S->base = NULL;
	S->top = NULL;
	S->size = 0;
	
	return 0;
}

int StackEmpty(SqStack S)
{
	//1 栈不存在 
	if(S.base == NULL)
	{
		return STACK_NOT_EXISTS;
	}
	
	if(S.top - S.base == 0)
	{
		return 1;
	}
	
	return 0;	
}

int StackLength(SqStack S)
{
	//1 栈不存在 
	if(S.base == NULL)
	{
		return STACK_NOT_EXISTS;
	}
	
	//2 返回栈的长度
	return S.top - S.base;
}

int GetSTop(SqStack S,ElemType *elem)
{
	if(S.base == NULL)
	{
		return STACK_NOT_EXISTS;  
	}
	
	if(S.top - S.base == 0)
	{
		return STACK_EMPTY;
	}	
	
	*elem = *(S.top - 1);
	
	return 0; 
}

int STraverse(SqStack S,void (*visit)(ElemType elem))
{
	//1若栈不存在 
	if(S.base == NULL)
	{
		return STACK_NOT_EXISTS;
	}
			
	if(S.top - S.base == 0)
	{
		return STACK_EMPTY;
	}
	
	//2 栈存在且有元素：依次遍历元素 
	int cnt = 0;

	ElemType *p = S.top;
	while(p != S.base)
	{
		(*visit)(*(p-1));
		printf("\t"); 
				
		if( (cnt+1) % LINE_DATA_NUMS == 0)
		{
			printf("\n");
		}
		
		cnt += 1;
		
		p--;
	}
	
	printf("\n");
	return 0;
}

int main()
{
	int n;
	ElemType elem;
	SqStack S;
	InitStack(&S);
	while(scanf("%d",&n)==1)
	{
		while(n)
		{
			Push(&S,n%8);
			n=n/8;
		}
		while(!StackEmpty(S))
		{
			Pop(&S,&elem);
			printf("%d",elem);
		}
		ClearStack(&S);
		printf("\n");
	}
	return 0;
}