二叉树和栈的基本操作

Tree.h：

#pragma once

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define TreeDataType char

/**二叉树数据结构定义**/
typedef struct BiTreeNode {
	TreeDataType data;
	struct BiTreeNode *left;
	struct BiTreeNode *right;
} BiTreeNode, *BiTree;

/**二叉树的建立--按照先序方式建立--插入**/
void CreateBiTree(BiTree *T);

/**先序遍历  根左右**/
void PreOrderTravel(BiTree T);

/**中序遍历 左根右**/
void InOrderTravel(BiTree T);

/**后序遍历 左右根**/
void TailOrderTravel(BiTree T);

Tree.c：

#include "Tree.h"
#define MAXSIZE 100
/**二叉树的建立--按照先序方式建立--插入**/
void CreateBiTree(BiTree *T) {
	char val;
	scanf("%c", &val);

	if (val == '#')
		*T = NULL; //null表示为空枝

	else {
		*T = (BiTree)malloc(sizeof(BiTreeNode));
		(*T)->data = val;
		CreateBiTree(&(*T)->left);
		CreateBiTree(&(*T)->right);
	}
}


/**先序遍历  根左右**/
void PreOrderTravel(BiTree T) {
	if (T == NULL)
		return;
	printf("%c ", T->data);
	PreOrderTravel(T->left);
	PreOrderTravel(T->right);
}

/**中序遍历 左根右**/
void InOrderTravel(BiTree T) {
	if (T == NULL)
		return;
	InOrderTravel(T->left);
	printf("%c ", T->data);
	InOrderTravel(T->right);
}

/**后序遍历 左右根**/
void TailOrderTravel(BiTree T) {
	if (T == NULL)
		return;
	TailOrderTravel(T->left);
	TailOrderTravel(T->right);
	printf("%c ", T->data);
}

Stack.h:

#pragma once

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

#define MAX_SIZE 100
typedef int StackDataType;
typedef struct Stack {
	StackDataType array[MAX_SIZE];
	int pop;

} Stack;

void StackInit(Stack* pStack); //初始化

void StackDestroy(Stack* pStack); //销毁

void StackPush(Stack* pStack, StackDataType data); //入栈

void StackPop(Stack* pStack); //出栈

StackDataType StackTop(Stack* pStack); //查看栈顶元素

int StackSize(const Stack* pStack); //栈长度

int StackFull(const Stack* pStack); //栈满

int StackEmpty(const Stack* pStack); //栈空

Stack.c:

#include "Stack.h"

void StackInit(Stack* pStack) //初始化
{
	pStack->pop = 0;
}

void StackDestroy(Stack* pStack) //销毁
{
	pStack->pop = 0;
}

void StackPush(Stack* pStack, StackDataType data) //入栈
{
	assert(pStack != NULL);
	pStack->array[pStack->pop] = data;
	pStack->pop++;
}

void StackPop(Stack* pStack) //出栈
{
	assert(pStack != NULL);
	pStack->pop--;
}


StackDataType StackTop(Stack* pStack) //查看在栈顶元素
{
	assert(pStack != NULL);
	return pStack->array[pStack->pop - 1];
}

int StackSize(const Stack* pStack) //栈长度
{
	return pStack->pop;
}

int StackFull(const Stack* pStack) //栈满
{
	if (pStack->pop >= MAX_SIZE) {
		return 1;
	}
	else
	{
		return 0;
	}
}

int StackEmpty(const Stack* pStack) //栈空
{
	if (pStack->pop == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

main.c:

#include <Windows.h>
#include "Stack.h" //栈
#include "Tree.h"  //树

//栈基本操作
void stackvoid() {
	Stack pStack;
	StackInit(&pStack); //初始化
	//StackDestroy(pStack);//销毁
	StackPush(&pStack, 1); //入栈
	StackDataType a = StackTop(&pStack);
	printf("把1入栈，当前栈顶元素：%d\n ", a);

	StackPush(&pStack, 3);
	a = StackTop(&pStack);
	printf("把3入栈，当前栈顶元素：%d \n", a);

	StackPush(&pStack, 5);
	a = StackTop(&pStack);
	printf("把5入栈，当前栈顶元素%d\n", a);

	StackPop(&pStack); //出栈
	a = StackTop(&pStack);
	printf("出栈，当前栈顶元素%d\n ", a);

	int b = StackSize(&pStack);  //栈长度
	int c = StackFull(&pStack);  //栈满
	int d = StackEmpty(&pStack); //栈空
	printf("栈长度：%d\n", b);
	printf("栈满否（1为满，0为未满）：%d\n", c);
	printf("栈空否（1为空，0为未空）：%d\n", d);
}

void ErChaShu() 
{
	printf("测试代码\n");
	BiTree T;
	T = (BiTree)malloc(sizeof(BiTreeNode));

	printf("请给二叉树按照先序方式依次输入结点的值(空结点为#):\n");
	CreateBiTree(&T);


	printf("先序方式遍历结果：\n");
	PreOrderTravel(T);
	printf("\n");

	printf("中序方式遍历结果：\n");
	InOrderTravel(T);
	printf("\n");

	printf("后序方式遍历结果：\n");
	TailOrderTravel(T);
	printf("\n");
}

int main() {
	//stackvoid();
	ErChaShu();
	system("pause");
	return 0;
}