数据结构—树的应用—C语言

数据结构—树的应用—C语言

概念：

			1. 树是非线性数据结构；
			2. 树分为多种；
			3. 树有度，深度，左右节点，叶子结点个数；
			4. 最常用的为二叉树；

计算方式

			1. n0 = n2-1;

存储方式

			1. 数据存储方式: 数组存储(顺序存储)，链式存储；
			2. 数组存储：左节点：(n/2-1)，右节点：（n/2+1）；
			3. 链式存储方式：通过结构体左右指针；

二叉树的结构体

	typedef int DataType; //存储节点的类型；
	typedef struct Tree   //二叉树的节点；
	{
		DataType data;
		struct Tree *left,*right;
	}*tree_node;

二叉树的创建（二叉排序树）

	tree_node* create_tree(tree_node *root)
	{
		DataType datas[6] = {8,5,2,1,3,4};
		tree_node *new_node,*current,*backup;
		// new_node: 创建新节点；
		// current: 保存当前树节点；
		// backup: 用于存储待插入数据的节点；
		for(int i=0;i<6;i++)
		{
			new_node = (struct Tree*)malloc(sizeof(tree_node));
			// 分配内存；
			new_node->data = datas[i];
			if(!root)
			{
				root = new_node;
				continue;
			}
			current = root;
			while(current)
			{
				backup = current;
				if(current->data>datas[i])
				{
					current = current->left;
				}
				else
				{
					current = current->right;
				}
			}
			if(backup->data>datas[i])
			{
				backup->left = new_node;
			}
			else
			{
				backup->right = new_node;
			}
		}
		return root;
	}

先序遍历(递归)

	void preorder(tree_node *root)
	{
		if(root)
		{	
			printf("%d\t",root->data);
			preorder(root->left);
			preorder(root->right);
		}
	}

先序遍历(非递归)

	void non_recursive_preorder(tree_node *root)
	{
		tree_node *ptr = root;
		tree_node *stack[6];
		int top = -1;
		while(ptr||top>=0)
		{
			if(ptr)
			{	
				stack[++top] = ptr;
				print("%d\t",ptr->data);
				ptr = ptr->left;
			}
			else
			{
				ptr = stack[top--];
				ptr = ptr->right;
			}
		}
	}

中序遍历(递归)

	void inorder(tree_node *root)
	{
		if(root)
		{
			inorder(root->left);
			printf("%d\t",root->data);
			inorder(root->right);
		}
	}

中序遍历(非递归)

void non_recursive_inorder(tree_node *root)
{
	tree_node *ptr = root;
	tree_node *stack[6];
	int top = -1;
	while(ptr||top>=1)
	{	
		if(ptr)
		{
			stack[++top] = ptr;
			ptr = ptr->left;
		}
		else
		{
			ptr = stack[top--];
			printf("%d\t",ptr->data);
			ptr = ptr->right;
		}
	}
}

后序遍历(递归)

	void postorder(tree_node *root)
	{
		if(root)
		{
			postorder(root->left);
			postorder(root->right);
			printf("%d\t",root->data);
		}
	}

后序遍历(非递归)

	void non_recursive_postorder(tree_node *root)
	{
		tree_node *stack1[6],*stack2[6],*ptr = root;
		int top1,top2;
		top1 = top2 = -1;
		stack1[top1++] = root;
		while(top1!=-1)
		{	
			tree_node *get_node = stack1[top1--];
			stack2[top2++] = get_node;
			if(get_node->left)
			{
				stack1[top1++] = get_node->left;
			}
			if(get_node->right)
			{
				stack[top1+=] = get_node->right;
			}
		}
		while(top2!=-1)
		{
			printf("%d\t",stack2[top2--].data);
		}
	}

树的深度

	int deep(tree_node *root)
	{
		if(!root)return 0;
		else
		{
			return max(deep(root->left),deep(root->right))+1;
		}
	}

树的度

	int degree(tree_node *root)
	{
		if(!root)return 0;
		else
		{
			return degree(root->left)+degree(root->right)+1;
		}
	}

树的最深路径

	void show_long(tree_node *root)
	{
		if(root)
		{
			printf("%d\t",root->data);
			if(deep(root->left)<deep(root->right))
			{
				show_long(root->right);
			}
			else
			{
				show_long(root->left);
			}
		}
	}

树的最浅路径

	void show_short(tree_node *root)
	{
		if(root)
		{
			printf("%d\t",root->data);
			if(deep(root->left)<deep(root->right))
			{
				show_long(root->left);
			}
			else
			{
				show_long(root->right);
			}
		}
	}

树的叶节点个数

int show_leaf_num(tree_node *root)
{
	int count = 0;
	if(!root)return 0;
	if(!root->left&&!root->right)count++;
	return count+show_leaf_num(root->left)+show_leaf_num(root->right);
}

树的度数为2的个数

int show_two_num(tree_node *root)
{
	int count = 0;
	if(!root)return 0;
	if(root->left&&root->right)count++;
	return count+show_leaf_num(root->left)+show_leaf_num(root->right);
}

树的度数为1的个数

int show_one_num(tree_node *root)
{
    int count = 0;
    if(!root)return 0;
    if((!root->left||root->right)&&(root->left&&!root->right)) count++;
    return count+show_one_num(root->left)+show_one_num(root->right);
}