1. Create a binary tree

1.1 The main step of creating a binary tree is to create left and right nodes. First, we create a binary tree statically.

• 1. Firstly, a structure is created to load the node of the tree. Secondly, a function is defined to generate the tree.

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

typedef struct node
{
	int n_value;
	struct node* p_left;
	struct node* p_right;
}BinaryTree;

BinaryTree* CreateTree()
{
	BinaryTree* p_tree = NULL;
	p_tree = (BinaryTree*)malloc(sizeof(BinaryTree));

	// Create the root node
	p_tree->n_value = 1;

	// Create the left of the root
	p_tree->p_left = (BinaryTree*)malloc(sizeof(BinaryTree));
	p_tree->p_left->n_value = 2;

	// Create the left left of the root
	p_tree->p_left->p_left = (BinaryTree*)malloc(sizeof(BinaryTree));
	p_tree->p_left->p_left->n_value = 4;
	p_tree->p_left->p_left->p_left = NULL;
	p_tree->p_left->p_left->p_right = NULL;

	// Create the left and right of the root
	p_tree->p_left->p_right = (BinaryTree*)malloc(sizeof(BinaryTree));
	p_tree->p_left->p_right->n_value = 5;
	p_tree->p_left->p_right->p_left = NULL;
	p_tree->p_left->p_right->p_right = NULL;

	// Create the right of the root
	p_tree->p_right = (BinaryTree*)malloc(sizeof(BinaryTree));
	p_tree->p_right->n_value = 3;

	// Create the right left of the root
	p_tree->p_right->p_left = (BinaryTree*)malloc(sizeof(BinaryTree));
	p_tree->p_right->p_left->n_value = 6;
	p_tree->p_right->p_left->p_left = NULL;
	p_tree->p_right->p_left->p_right = NULL;

	// Create the right of the root
	p_tree->p_right->p_right = NULL;

	return p_tree;
}

int main()
{
	BinaryTree* p_tree = NULL;
	p_tree = CreateTree();

	return 0;
}

• 2. We debug the next breakpoint to determine the success of the creation.

1.2 Traversing a Binary Tree

• 1. It can be traversed by depth. There are three methods of traversing binary tree in depth: pre-order traversal, middle-order traversal and post-order traversal.
• 2. It can traverse by breadth; breadth traverses binary trees;
• 3. First, the preface traversal is carried out by recursive method.

void PreorderTraversal(BinaryTree *p_tree)
{
	// Exit conditions
	if(p_tree == NULL)return;

	// root
	printf("%d ", p_tree->n_value);

	// Left
	PreorderTraversal(p_tree->p_left);

	// right
	PreorderTraversal(p_tree->p_right);
}

• 4. The results obtained by using the preamble traversal are as follows: 1 24 5 3 6;
• 5. Use recursive method to complete the intermediate traversal;

void InorderTraversal(BinaryTree *p_tree)
{
	// Exit conditions
	if(p_tree == NULL)return;

	// Left
	InorderTraversal(p_tree->p_left);

	// root
	printf("%d ", p_tree->n_value);

	// right
	InorderTraversal(p_tree->p_right);
}

• 6. The results obtained by using intermediate order traversal are 425 163;
• 7. Complete the post-order traversal by recursion.

void LastorderTraversal(BinaryTree *p_tree)
{
	// Exit conditions
	if(p_tree == NULL)return;

	// Left
	LastorderTraversal(p_tree->p_left);

	// right
	LastorderTraversal(p_tree->p_right);

	// root
	printf("%d ", p_tree->n_value);
}

• 8. The results of post-order traversal are as follows: 45,226,31;

1.3 Dynamic creation of a binary tree

• 1. Recursive thinking is also needed. We need to apply for space for tree nodes to load trees, and then deal with left and right.

void DynamicCreateTree(BinaryTree** pp_tree)
{
	int num;
	scanf("%d ", &num);

	// Processing left and right nodes
	if(num == 0)return;

	// Processing tree nodes
	*pp_tree = (BinaryTree*)malloc(sizeof(BinaryTree));
	(*pp_tree)->n_value = num;
	(*pp_tree)->p_left = NULL;
	(*pp_tree)->p_right = NULL;

	// Processing left and right nodes of tree nodes
	DynamicCreateTree(&((*pp_tree)->p_left));
	DynamicCreateTree(&((*pp_tree)->p_right));
}