创建二叉树及二叉树三种遍历(上)

准备工作一览

为了创建一颗二叉树，需要使用到自动状态变迁图和堆栈等，详细需要：
(1)，定义基本类型和的mec.h和包含mec.h的跳过空格的mec.c
(2)，定义显示错误的error.h和具体显示错误函数的error.c
(3)，定义堆栈结构定义处理堆栈函数的stack.h和具体操作堆栈的stack.c

准备工作1- mec.c 和mec.h的创建

//mec.h头文件
#ifndef _MEC_H_
#define _MEC_H_

typedef unsigned char		boolean;
typedef boolean				u8;
typedef unsigned short		u16;
typedef unsigned int		u32;

#define TRUE		1
#define FALSE		0

#define NOT_FOUND	-1

#define SET(n, i)	((n) | (1 << ((i) ^ 7)))
#define CLR(n, i)	((n) & ~(1 << ((i) ^ 7)))
#define GET(n, i)	(((n) >> ((i) ^ 7)) & 1)

int skipBlank(const char *str);

#endif

//mec.c最终经过gcc编译成.o文件与test.c联合编译
#include <ctype.h>
//ctype.h文件用于测试字符是否属于特定的字符类别，
//如字母字符、控制字符。

#include "mec.h"

//skipBlank()函数包括isspace()函数用下标来跳过空格
int skipBlank(const char *str) {
	int i;

	for (i = 0; str[i] && isspace(str[i]); i++) {
	}

	return i;
}

准备工作2- error.h和error.c的创建

//mecError.h头文件
#ifndef _MEC_ERROR_H_
#define _MEC_ERROR_H_

void showError();

#endif

//mecError.c最终经过gcc编译成.o文件与test.c联合编译
#include <stdio.h>
#include "mecError.h"

const char *errMess = NULL;
//这里采用指针的方法来打印错误

void showError() {
	if (NULL == errMess) {
		return;
	}
	printf("%s\n", errMess);
}

准备工作3- stack.h 和stack.h的创建

在进行二叉树的创建时，需要一个栈来存储有孩子的非子叶结点，这里会在后面创建二叉树时详细描述

//stack.h头文件
#ifndef _MEC_STACK_H_
#define _MEC_STACK_H_

#include "mec.h"

typedef struct MEC_STACK {
	void **stack;
	int capacity;
	int top;
}MEC_STACK;

boolean initStack(MEC_STACK **stack, int capacity);
void destoryStack(MEC_STACK **stack);
boolean isStackEmpty(const MEC_STACK *stack);
boolean isStackFull(const MEC_STACK *stack);
boolean push(MEC_STACK *stack, void *data);
void *pop(MEC_STACK *stack);
void *readTop(const MEC_STACK *stack);
//stack.h文件定义了一系列对栈的操作，包括初始化，销毁，
//判断栈的满或空状态，入栈和出栈，读取栈顶元素的功能
#endif

//stack.c通过gcc编译成.o文件最终与test.c联合编译
//栈本质是个数组，所有入栈，出栈，读取栈顶指针
//只不过是移动一个‘指针’，操作它对所谓的 栈顶进行操作
//栈顶‘指针’的下一个元素才是此时位于栈顶的首元素
#include <stdio.h>
#include <malloc.h>

#include "mec.h"
#include "stack.h"

//初始化前进行一系列有效性检查
boolean initStack(MEC_STACK **stack, int capacity) {
	MEC_STACK *result;

	if (NULL == stack || NULL != *stack || capacity <= 0) {
		return FALSE;
	}

	result = (MEC_STACK *) calloc(sizeof(MEC_STACK), 1);
	if (NULL == result) {
		return FALSE;
	}
	
	result->stack = (void **) calloc(sizeof(void *), capacity);
	if (NULL == result->stack) {
		free(result);
		return FALSE;
	}

	result->capacity = capacity;
	result->top = 0;

	*stack = result;

	return TRUE;
}

//销毁，所有使用动态申请存储空间方法申请的空间都必须被free()
void destoryStack(MEC_STACK **stack) {
	if (NULL == stack || NULL == *stack) {
		return;
	}
	free((*stack)->stack);
	free(*stack);

	*stack = NULL;
}

//栈判空
boolean isStackEmpty(const MEC_STACK *stack) {
	return NULL == stack || stack->top <= 0;
}

//栈判满
boolean isStackFull(const MEC_STACK *stack) {
	return NULL == stack || stack->top >= stack->capacity;
}

//入栈
boolean push(MEC_STACK *stack, void *data) {
	if (NULL == stack || isStackFull(stack)) {
		return FALSE;
	}
	stack->stack[stack->top++] = data;

	return TRUE;
}

//出栈
void *pop(MEC_STACK *stack) {
	if (NULL == stack || isStackEmpty(stack)) {
		return NULL;
	}

	return stack->stack[--stack->top];
}

//读取当前栈顶元素
void *readTop(const MEC_STACK *stack) {
	if (NULL == stack || isStackEmpty(stack)) {
		return NULL;
	}

	return stack->stack[stack->top - 1];
}