二叉树

二叉树递归遍历

// 二叉树.cpp : 定义控制台应用程序的入口点。

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

//
//
//
typedef struct BINARYNODE {
	char ch;
	struct BINARYNODE* lchild;
	struct BINARYNODE* rchild;

}BinaryNode;

//递归遍历
void recursion(BinaryNode *root)
{
	if (root == NULL)
		return;
	
	//先序遍历
	//printf("%c", root->ch);//遍历根
	//recursion(root->lchild);//遍历左
	//recursion(root->rchild);//遍历右

	//中遍历
	recursion(root->lchild);
	printf("%c", root->ch);
	recursion(root->rchild);

	//后遍历
	//printf("%c", root->ch);
	//recursion(root->rchild);
	//recursion(root->lchild);
}

//计算叶子节点
void calLeafNum(BinaryNode*root, int*leafNum)
{
	if (root == NULL)
		return;
	if (root->lchild == NULL&&root->rchild == NULL)
	{
		(*leafNum)++;
	}
	calLeafNum(root->lchild, leafNum);//左子树叶子节点数
	calLeafNum(root->rchild, leafNum);//右子树叶子节点数

}

//求二叉树的高度
int CaculateTreeDepth(BinaryNode* root) {

	if (root == NULL) {
		return 0;
	}

	int depth = 0;
	//求左子树的高度
	int leftDepth = CaculateTreeDepth(root->lchild);
	int rightDepth = CaculateTreeDepth(root->rchild);
	depth = leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;

	return depth;
}

//拷贝二叉树
BinaryNode* copyBinaryTree(BinaryNode* root) {
	if (root == NULL) {
		return 0;
	}

	BinaryNode*lchild =copyBinaryTree(root->lchild);
	BinaryNode*rchild =copyBinaryTree(root->rchild);
	//创建节点
	BinaryNode*newnode = (BinaryNode*)malloc(sizeof(BinaryNode));
	newnode->ch = root->ch;
	newnode->lchild = lchild;
	newnode->rchild =rchild;

	return newnode;
}

//释放二叉树内存
void freeBinaryTree(BinaryNode* root)
{
	if (root == NULL) {
		return;
	}

		freeBinaryTree(root->lchild);
		freeBinaryTree(root->rchild);
		free(root);
		root = NULL;
}


void crrateBinaryLink()
{
	BinaryNode node1 = { 'A',NULL,NULL };	//		A
	BinaryNode node2 = { 'B',NULL,NULL };	//	B		F
	BinaryNode node3 = { 'C',NULL,NULL };	// C			G
	BinaryNode node4 = { 'D',NULL,NULL };	//D	 E	       H
	BinaryNode node5 = { 'E',NULL,NULL };
	BinaryNode node6 = { 'F',NULL,NULL };
	BinaryNode node7 = { 'G',NULL,NULL };
	BinaryNode node8 = { 'H',NULL,NULL };

	//建立节点关系
	node1.lchild = &node2;
	node1.rchild = &node6;
	node2.rchild = &node3;
	node3.lchild = &node4;
	node3.rchild = &node5;
	node6.rchild = &node7;
	node7.lchild = &node8;

	//recursion(&node1);

	//int leafNum=0;
	//calLeafNum(&node1, &leafNum);
	//	printf("叶子数：%d",leafNum);

	//int depth = CaculateTreeDepth(&node1);
	//printf("树的高度为:%d\n", depth);

	BinaryNode*root = copyBinaryTree(&node1);
	recursion(root);
	freeBinaryTree(root);
}



int main()
{
	crrateBinaryLink();

	printf("\n");
	system("pause");
	return 0;
}
```c

二叉树非递归遍历

// 二叉树.cpp : 定义控制台应用程序的入口点。

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

#define FALSE 0
#define TRUE  1
//链式栈的结点
typedef struct LINKNODE {
	struct LINKNODE* next;
}LinkNode;

//链式栈
typedef struct LINKSTACK {
	LinkNode head;
	int size;
}LinkStack;

LinkStack* Init_LinkStack() {

	LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
	stack->head.next = NULL;
	stack->size = 0;

	return stack;
}
//入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data) {

	if (stack == NULL) {
		return;
	}

	if (data == NULL) {
		return;
	}

	data->next = stack->head.next;
	stack->head.next = data;
	stack->size++;
}
//出栈
void Pop_LinkStack(LinkStack* stack) {
	if (stack == NULL) {
		return;
	}

	if (stack->size == 0) {
		return;
	}

	//第一个有效结点
	LinkNode* pNext = stack->head.next;
	stack->head.next = pNext->next;

	stack->size--;
}
//返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack) {
	if (stack == NULL) {
		return NULL;
	}
	if (stack->size == 0) {
		return NULL;
	}
	return stack->head.next;
}
//返回栈元素的个数
int Size_LinkStack(LinkStack* stack) {
	if (stack == NULL) {
		return -1;
	}
	return stack->size;
}
//清空栈
void Clear_LinkStack(LinkStack* stack) {
	if (stack == NULL) {
		return;
	}
	stack->head.next = NULL;
	stack->size = 0;
}
//销毁栈
void FreeSpace_LinkStack(LinkStack* stack) {
	if (stack == NULL) {
		return;
	}
	free(stack);
}


typedef struct BINARYNODE {
	char ch;
	struct BINARYNODE* lchild;
	struct BINARYNODE* rchild;

}BinaryNode;

//放入栈的节点
typedef struct TREESTACKNODE {
	LinkNode node;
	BinaryNode* root;
	int flag;

}TreeStackNode;

//创建栈中节点
TreeStackNode*  createTreeStackNode(BinaryNode* root,int flag)
{
	TreeStackNode*newnode =(TreeStackNode*) malloc(sizeof(TreeStackNode));
	newnode->root = root;
	newnode->flag = flag;

	return newnode;
}

//非递归遍历
void Traversal(BinaryNode* root)
{
	LinkStack*stack = Init_LinkStack();

	Push_LinkStack(stack,(LinkNode*)createTreeStackNode(root,FALSE));

	while (Size_LinkStack(stack)>0)
	{
		TreeStackNode* node = (TreeStackNode*)Top_LinkStack(stack);//弹出栈顶元素
		Pop_LinkStack(stack);

		if (node->root == NULL)
			continue;
			
		if (node->flag == TRUE)//遍历到一个节点，否则将下一个节点入栈
			printf("%c", node->root->ch);
		
		else//入栈顺序与遍历顺序相反
		{
			//先序遍历
			Push_LinkStack(stack, (LinkNode*)createTreeStackNode(node->root->rchild, FALSE));//右节点
			Push_LinkStack(stack, (LinkNode*)createTreeStackNode(node->root->lchild, FALSE));//左节点

			node->flag = TRUE;
			Push_LinkStack(stack, (LinkNode*)node);
			
		}
	}

}


void crrateBinaryLink()
{
	BinaryNode node1 = { 'A',NULL,NULL };	//		A
	BinaryNode node2 = { 'B',NULL,NULL };	//	B		F
	BinaryNode node3 = { 'C',NULL,NULL };	// C			G
	BinaryNode node4 = { 'D',NULL,NULL };	//D	 E	       H
	BinaryNode node5 = { 'E',NULL,NULL };
	BinaryNode node6 = { 'F',NULL,NULL };
	BinaryNode node7 = { 'G',NULL,NULL };
	BinaryNode node8 = { 'H',NULL,NULL };

	//建立节点关系
	node1.lchild = &node2;
	node1.rchild = &node6;
	node2.rchild = &node3;
	node3.lchild = &node4;
	node3.rchild = &node5;
	node6.rchild = &node7;
	node7.lchild = &node8;

	Traversal(&node1);

}


int main()
{
	crrateBinaryLink();

	printf("\n");
	system("pause");
	return 0;
}