18.8.10简单二叉树 和 归并排序

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

算法步骤：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置

3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

4. 重复步骤3直到某一指针达到序列尾

5. 将另一序列剩下的所有元素直接复制到合并序列尾

动图链接：https://www.cnblogs.com/RainyBear/p/5258483.html

代码实现：

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

void Merge(int array[],int start, int middle ,int end )
{
	int i,j,k,num1,num2;
	num1 = middle + 1 - start ;
	num2 = end - middle;
	
	int *A = (int*)malloc(sizeof(int)*num1); 
	int *B = (int*)malloc(sizeof(int)*num2);
	
	for(i = 0, k = start;i < num1 ; i++,k++)  // 形成有序序列A
	{
		A[i] = array[k];
	}
	
	for(i = 0,k = middle + 1;i < num2;i++,k++) // 形成有序序列B
	{
		B[i] = array[k];
	}
	
	for(i = 0, j = 0, k = start;i < num1 && j < num2 ;k++) // 合并至"array"数组中
	{
		if( A[i] < B[j] )
		{
			array[k] = A[i];
			i++;
		}
		else
		{
			array[k] = B[j];
			j++;
		}
	}
	
	if( i < num1 )      //再次判断A和B中哪一个有多余
	{
		for( j = i; j < num1; j++,k++)
		{
			array[k] = A[j];
		}
	}
	
	if( j < num2 )      
	{
		for( i = j;i < num2 ; i++,k++)
		{
			array[k] = B[i];
		}
	}
}

void MergeSort(int array[], int start,int  end )
{
	int middle;
	
	if( start < end )   // 进行递归算法 将 无序数组 分割成 单个元素。
	{
		middle = (start + end )/2;
	
		MergeSort(array,start,middle);
		MergeSort(array,middle+1,end);
		
		Merge(array,start,middle,end);
	}
	
}

int main()
{
	int i;
	int a[] = {99,88,77,76,55,44,33,22,11,4};
	int length = sizeof( a ) / sizeof( a[0] );
	
	MergeSort(a, 0, length - 1 );
	
	i = 0 ;
	while( i < length )
	{
		printf("%d ",a[i]);
		i++;
	}
	
	return 0;
}

 

二叉树的性质：
1.在二叉树的第i层至多有2^(i-1)个结点

2.深度为k的二叉树至多有2^k-1个结点

3.对任何一颗二叉树T，如果其终端结点数为n，度为2的结点数为m，则n=m+1

4.具有n个结点的完全二叉树的深度为
log2(n)+1

5.如果对1棵有n个结点的二叉树的结点按层序编号，对任一结点i：
(1)如果 i = 1，则结点 i 是二叉树的根，无双亲，如果 i > 1 , 则其双亲是结点( i / 2)
(2)如果 2i > n, 则结点 i 无左孩子，否则， 其左孩子是 2i
(3)如果 2i + 1 > n, 则结点i无右孩子；否则其右孩子是结点 2i + 1

二叉树的初始化 以及 前序中序和后序遍历： 

struct Node
{
	int data;
	struct Node *left,*right;
};

typedef struct Node TreeNode;

TreeNode *CreatTree (int *a)
{
	int i;
	TreeNode *node[10 + 1] = {0};
	
	i = 0;
	while( i < 10 )
	{
		node[i] = (TreeNode*)malloc(sizeof(TreeNode));
		if( NULL == node[i] )
		{
			printf("malloc error!\n");
		}
		
		node[i]->data  = a[i];
		node[i]->right = NULL;
		node[i]->left  = NULL;
		i++;
	}
	
	for( i = 0; i < 10 / 2 ; i++)
	{
		node[i]->left = node[ 2 * i + 1];
		node[i]->right= node[ 2 * i + 2];
	}
	return node[0];
}

int PreOrder(TreeNode* t)//前序遍历
{
	if( NULL == t )
	{
		return 1;
	}
	
	printf("%d ",t->data);
	PreOrder( t->left );
	PreOrder( t->right );
		
	return 0;
}

int InOrder(TreeNode* t)//中序遍历
{
	if( NULL == t )
	{
		return 1;
	}
	
	InOrder( t->left );
	printf("%d ",t->data);
	InOrder( t->right );
		
	return 0;
}

int PostOrder(TreeNode* t)//后序遍历
{
	if( NULL == t )
	{
		return 1;
	}
	
	PostOrder( t->left );
	PostOrder( t->right );
	printf("%d ",t->data);
		
	return 0;
}

int main()
{
	int a[10] = {1,2,3,4,5,6,7,8,9,0};
	TreeNode *root;
	
	root = CreatTree(a);
	
	PreOrder( root );
	printf("\n");
	
	InOrder( root );
	printf("\n");
	
	PostOrder( root );
	printf("\n");
	
	return 0;
}