二叉树
树形的最简单的模型，每个节点最多有两个子节点
一般来说，非二叉树，可以简化成二叉树
每个子节点有且仅有一个父节点，整棵树只有一个根节点
具有递归的结构特征，用递归的方法处理，可以简化算法
三种遍历序：
前序遍历 D-L-R
中序遍历 L-D-R
后序遍历 L-R-D
比如：1是根节点 2是左子节点 3是右子节点
前序遍历 1 2 3
中序遍历 2 1 3
后序遍历 2 3 1
二叉树的一般形式：
根节点、枝节点、叶节点
父节点和子节点
左子节点和右子节点
左子树和右子树
大小和高度（深度）
满二叉树和完全二叉树
满二叉树：
每层节点数均达到最大值
所有枝节点均有左右子树
完全二叉树：
前面n-1 层是满的，最后1层可以不满，
但是从左向右连续排列
平衡二叉树：
左右层数不能相差1的；
二叉树的编码实现：
顺序二叉树 -----数组只能还原完全二叉树，所以不是完全二叉树的 需要变成完全二叉树
最大的问题 就是如果二叉树离完全二叉树标准特别远，内存的浪费非常大。
因此二叉树虽然可以用 顺序结构实现，但更常见的用链表实现。
链式表二叉树
每个节点由 数据、左子节点和右子节点组成（二叉链表）。也可以加上父节点指针（三叉链表）。
二叉链表实现的二叉树 单向的; 三叉链表实现的是二叉树是 双向的。
struct BsTreeNode{
int data;//数据
struct BsTreeNode* left;//左子节点，也可以代表左边的子树
struct BsTreeNode* right;//右子节点，也可以代表右边的子树
};
编码实现 有序二叉树：
有序二叉树的原理：
首先有一个根节点（第一个节点），放入第二个节点的时候，和根节点比较，如果比根节点大，放
在根节点的右边，如果小则放在左边。（相等的话，看情况处理）。
左右子树亦分别为有序二叉树。
基于有序二叉树的排序和查找，可获得O(logN)级的平均时间复杂度
回顾：
二叉树，最简单的树型结构，每个父节点最多有两个子节点
二叉树具备递归的特征，所以编码时会大量使用递归。
二叉树有顺序结构和链式结构两种实现方式，顺序结构的实现方式必须存储完全二叉树，
不是完全二叉树的用空节点补成二叉树以后存储，因此内存上浪费比较大。
链式结构的二叉树分为二叉链表实现和三叉链表实现，三叉链表多了父节点的指针。
二叉树的遍历分为三种：前序、中序、后序
算法：
数据结构 存一起
算法 算一下
广义上说，算法就是解决问题的方法。（说到底是数学问题）
排序算法：----无序变成有序
冒泡、选择、插入、快速、归并
查找算法：----查找数据
线性查找（从头到尾查找）二分查找（有序，从中间开始查找）
冒泡排序：排序有升序和降序，升序就是从小到大，降序就是从大到小。
算法：
相邻的比较，如果前面比后面大，交换。从第一对比到最后一对，最大就在最后面。
依次对前面的元素进行相同的操作。n-1轮以后，排序成功。
假如有一轮 依次都没有交换的话，则说明有序了。
1. 相邻的预算两两比较，前者大于后者，彼此交换
2. 从第一对到最后一对，最大元素沉降到最后
3. 针对未排序部分，重复以上步骤，沉降次大值
4. 每次扫描越来越少的元素，直至不再发生交换
评价：
平均时间复杂度O(N的平方)
稳定排序
对数据的有序性非常敏感
冒泡排序效率总体来说是比较低的。平均时间复杂度O的平方，就是N的平方次。
但如果排序前就基本有序的话，则冒泡的效率就很高了。
1 #include
2 #include
3 //数组做参数，必须指定数组长度，数组不能返回
4 void bubble_sort(int data[],size_t size){//冒泡排序
5 int i,j;
6 for(i=0;i data[j+1]){//前面的比后面大
12 int temp = data[j];//交换算法
13 data[j] = data[j+1];
14 data[j+1] = temp;
15 flag=0;//发生了交换
16 }
17 }
18 if (flag) break;//没有交换就退出
19 }
20 }
21 int main()
22 {
23 int a[]={4,3,2,1,5,7,6};
24 bubble_sort(a,7);
25 int i;
26 for(i=0;i<7;i++)
27 printf("%d\n",a[i]);
28 return 0;
29 }
插入排序 1-n
算法：
第一个元素必然有序，然后把第二个到第n个元素插入前面的有序序列中，保证每次插入以后依然有序。
如何保持插入后依然有序呢？
把插入的数据和前面的数据进行比较，如果插入数据比前面数据小的话，前面的数据后移一位，插入数据
继续向前比较，如果插入数据不比前面的数据小的话，把数据插入到前面的数据后面即可。如果已经比较
到最前面的数据话，插入数据依然最小，插入数据放在第一位即可。
1 首元素自然有序
2 取出下一个元素，对已排序序列，从后向前扫描
3 大于被取出元素者后移
4 小于等于被取出元素者，将被取出元素插入其后
5 重复步骤2，直至处理完所有元素
评价
平均时间复杂度O（N的平方）
稳定排序
对数据的有序性非常敏感
不交换只移动，优于冒泡排序
1 #include
2 #include
3
4 void insert_sort(int data[],size_t size){//插入排序
5 int i,j;
6 for(i=1;i0 && inserted < data[j-1]);j--){//从最后向前依次比较
9 data[j] = data[j-1];//后移动一位，不需要交换
10 }
11 data[j] = inserted;//j就是inserted应该插入的下标
12
13 }
14
15 }
16
17 int main()
18 {
19 int a[]={4,3,2,1,5,7,6};
20 insert_sort(a,7);
21 int i;
22 for(i=0;i<7;i++)
23 printf("%d\n",a[i]);
24 return 0;
25 }
选择排序：
求数组最小值的算法：
int arr[];
int min = arr[0];
for(i=0;i
2 #include
3 void select_sort(int data[],size_t size){//选择排序
4 //思路：先从头开始记录最小值的下标，然后和i下标做数据交换
5 int i,j,min;
6 for (i=0;i
2 #include
3 void quick_sort(int data[],size_t left,size_t right){//快速排序,全或部分
4 size_t p = (left+right)/2;//以中间做基准
5 int num = data[p];//把基准数取出来。
6 int i = left;
7 int j = right;
8 while(i=p || numdata[j]);j--);
16 if (j>p)
17 {
18 data[p] = data[j];
19 p = j;
20 }
21 }
22 data[p] = num;//基准数放入应该在的位置，归位
23 if ((p - left) > 1) quick_sort(data,left,p-1);
24 if ((right - p) > 1) quick_sort(data,p+1,right);
25 }
26 int main()
27 {
28 int data[]={4,3,5,7,1,2,6};
29 quick_sort(data,0,6);
30 int i;
31 for (i=0;i<7;i++)
32 printf("%d\n",data[i]);
33 return 0;
34 }
查找算法 ：
线性查找-----从头到尾找一遍，如果有，就退出循环，如果没有，循环结束就知道了。
二分查找-----必须是有序元素才能使用二分查找。
从中间点开始查找，如果大于 去后半部分，如果小于 去前半部分。
每次查找都是从中间点开始。
1 #include
2 #include
3 //返回find的下标，如果找不到返回-1;
4 int line_find(int data[],size_t size,int find){
5 int i;
6 for (i=0;idata[mid]) left = mid + 1;
21 else return mid;
22 }
23 return -1;
24 }
25 int main()
26 {
27 int data[]={7,2,4,5,1,3,6};
28 int in = line_find(data,7,2);
29 printf("in = %d\n",in);
30 int in1 = line_find(data,7,20);
31 printf("in1 = %d\n",in1);
32 int data2[]={1,2,3,4,5,6,7,8};
33 int in2 = half_find(data2,7,2);
34 printf("in2 = %d\n",in2);
35 int in3 = half_find(data2,7,20);
36 printf("in3 = %d\n",in3);
37
38 }
39
