二叉树遍历的实现

最新推荐文章于 2024-01-27 15:36:29 发布

jingsuxuyilq

最新推荐文章于 2024-01-27 15:36:29 发布

阅读量793

点赞数

分类专栏：算法 C

本文链接：https://blog.csdn.net/jingsuxuyilq/article/details/8655927

版权

C 同时被 2 个专栏收录

33 篇文章 0 订阅

订阅专栏

算法

13 篇文章 0 订阅

订阅专栏

下面是二叉树的遍历算法实现，不过对于后序非递归的实现还有点点问题，有空再更新。

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#define OK 1
#define FAIL 0
#define INPUTPARA "%c"
#define STACKSIZE 100
/**********define some primary data type************/
typedef char dataType;
typedef int status;
typedef struct node * binaryTreePointer;
struct node
{
	dataType data;
	binaryTreePointer leftChild, rightChild;
};
/**********define a global stack***************/
binaryTreePointer stack[STACKSIZE];
binaryTreePointer stack1[STACKSIZE];
/**************push stack************/
status pushStack(binaryTreePointer *stack, int *top, binaryTreePointer element)
{
	if(*top >= STACKSIZE - 1)
	{
		printf("\nstack is full\n,%d",*top);
		return FAIL;
	}
	if(NULL != element)
	{
		stack[++*top] = element;
	}
	return OK;
}
/*********pop stack**********/
status popStack(binaryTreePointer *stack, int *top, binaryTreePointer *element)
{
	if(-1 == *top)
	{
		return;
	}
	*element = stack[(*top)--];
	return OK;
}
/********create a binary tree***************/
status createBinaryTree(binaryTreePointer *root)
{
	dataType dataInput;
	scanf(INPUTPARA, &dataInput);
	if('#' == dataInput)
	{
		*root = NULL;
	}
	else
	{
		if(NULL == (*root = (binaryTreePointer)malloc(sizeof(struct node))))
		{
			printf("allocate memory error");
			return FAIL;
		}
		(*root)->data = dataInput;
		createBinaryTree(&(*root)->leftChild);
		createBinaryTree(&(*root)->rightChild);
	}
	return OK;
}
/*******delete a binary tree*********/
status deleteBinaryTree(binaryTreePointer root)
{
	if(NULL != root)
	{
		deleteBinaryTree(root->leftChild);
		deleteBinaryTree(root->rightChild);
		free(root);
	}
	return OK;
}
/*************preorder tree traversal(include recursion and non one)******************/
status preorderRecu(binaryTreePointer root)
{
	if(NULL != root)
	{
		printf(INPUTPARA, root->data);
		preorderRecu(root->leftChild);
		preorderRecu(root->rightChild);
	}
	return OK;
}

status preorderNonRecu(binaryTreePointer node)
{
	int top = -1;
	while(1)
	{
		for( ; NULL != node; node = node->leftChild)
		{
			printf(INPUTPARA, node->data);
			pushStack(stack, &top, node->rightChild);
		}
		popStack(stack, &top, &node);
		if(NULL == node)
		{
			break;
		}
	}
	return OK;
}
/*************inorder tree traversal(include recursion and non one)******************/
status inorderRecu(binaryTreePointer root)
{
	if(NULL != root)
	{
		inorderRecu(root->leftChild);
		printf(INPUTPARA, root->data);
		inorderRecu(root->rightChild);
	}
	return OK;
}

status inorderNonRecu(binaryTreePointer node)
{
	int top = -1;
	while(1)
	{
		for( ; NULL != node; node = node->leftChild)
		{
			pushStack(stack, &top, node);
		}
		popStack(stack, &top, &node);
		if(NULL == node)
		{
			break;
		}
		printf(INPUTPARA, node->data);
		node = node->rightChild;
	}
	return OK;
}
/*************inorder tree traversal(include recursion and non one)******************/
status postorderRecu(binaryTreePointer root)
{
	if(NULL != root)
	{
		postorderRecu(root->leftChild);
		postorderRecu(root->rightChild);
		printf(INPUTPARA, root->data);
	}
	return OK;
}
/*
status postorderNonRecu(binaryTreePointer node)
{
	int top = -1;
	binaryTreePointer tempNode = node;
	while(1)
	{
		for( ; NULL != node; node = node->rightChild)
		{
			pushStack(stack, &top, node);
			//printf(INPUTPARA, node->data);
			node = node->leftChild;
		}
		popStack(stack, &top, &node);
		if(NULL == node)
		{
			break;
		}
		printf(INPUTPARA, node->data);
		//node = node->rightChild;
	}
	return OK;
}
*/

int main(void)
{
	binaryTreePointer treeRoot = NULL;
	/**********initialize stack**************/
	(void)memset(stack, 0, STACKSIZE*sizeof(binaryTreePointer));
	/***********create a binary tree************/
	printf("create a binary tree:\n");
	if(OK != createBinaryTree(&treeRoot))
	{
		printf("error for creating a binary tree.\n");
		return -1;
	}
	/**************preorder tree travelsal*****************/
	printf("\npreorder recursion:\n");
	if(OK != preorderRecu(treeRoot))
	{
		printf("error for preorder recursion.\n");
		return -1;
	}
	printf("\nperorder non recursion:\n");
	if(OK != preorderNonRecu(treeRoot))
	{
		printf("error for preorder non recursion.\n");
		return -1;
	}
	/**************inorder tree travelsal*****************/
	printf("\ninorder recursion:\n");
	if(OK != inorderRecu(treeRoot))
	{
		printf("error for inorder recursion.\n");
		return -1;
	}
	printf("\ninorder non recursion:\n");
	if(OK != inorderNonRecu(treeRoot))
	{
		printf("error for inorder non recursion.\n");
		return -1;
	}
	/**************postorder tree travelsal*****************/
	printf("\npostorder recursion:\n");
	if(OK != postorderRecu(treeRoot))
	{
		printf("error for postorder recursion.\n");
		return -1;
	}
	/*printf("\npostorder non recursion:\n");
	if(OK != postorderNonRecu(treeRoot))
	{
		printf("error for postorder non recursion.\n");
		return -1;
	}*/
	/**************delete the binary tree*****************/
	if(OK != deleteBinaryTree(treeRoot))
	{
		printf("error for delete binary tree");
		return -1;
	}
	return 0;
}