1.二叉树：
有关树的专业术语：
结点
和链表类似，树存储结构中也将存储的各个元素称为
"
结点
"
。
对于树中某些特殊位置的结点，还可以进行更细致的划分，比如：
父结点（双亲结点）、孩子结点和兄弟结点：
树根结点（简称
"
根结点
"
）：特指树中没有双亲（父亲）的结点，一棵树有且仅有一个根结点。
叶子结点（简称
"
叶结点
"
）：特指树中没有孩子的结点，一棵树可以有多个叶子结点。
子树
通常，我们将一棵树中几个结点构成的
“
小树
”
称为这棵树的
“
子树
”
。
知道了子树的概念后，树也可以这样定义：树是由根结点和若干棵子树构成的。
注意：单个结点也可以看作是一棵树，该结点即为根结点。
结点的度
一个结点拥有子树的个数，就称为该结点的度（
Degree
）。
比较一棵树中所有结点的度，最大的度即为整棵树的度。
结点的层次
从一棵树的树根开始，树根所在层为第一层，根的孩子结点所在的层为第二层，依次类推。
树中结点层次的最大值，称为这棵树的深度或者高度。
有序树和无序树
如果一棵树中，各个结点左子树和右子树的位置不能交换，那么这棵树就称为有序树。反之，如果
树中结点的左、右子树可以互换，那么这棵树就是一棵无序树。
在有序树中，结点最左边的子树称为
"
第一个孩子
"
，最右边的称为
"
最后一个孩子
"
。
森林
由
m
（
m >= 0
）个互不相交的树组成的集合就称为森林。
前面讲到，树可以理解为是由根结点和若干子树构成的，而这若干子树本身就是一个森林，因此树
还可以理解为是由根结点和森林组成的。
空树（简单了解即可）
空树指的是没有任何结点的树，连根结点都没有。
总结：树是一种非线性存储结构，通常用来存储逻辑关系为
"
一对多
"
的数据。
使用树结构存储的各个结点，它们之间的关系类似于家谱中的成员关系，比如有父子关系、兄弟关系、表兄弟关系等。
二叉树概念：
满足以下两个条件的树就是二叉树：
1.
本身是有序树；
2.
树中包含的各个节点的度不能超过
2
，即只能是
0
、
1
或者
2
；
二叉树具有以下几个性质：
1.
二叉树中，第
i
层最多有
2i-1
个结点。
2.
如果二叉树的深度为
K
，那么此二叉树最多有
2K-1
个结点。
3.
二叉树中，终端结点数（叶子结点数）为
n0
，度为
2
的结点数为
n2
，则
n0=n2+1
。
性质
3
的计算方法为：对于一个二叉树来说，除了度为
0
的叶子结点和度为
2
的结点，剩下的就是度为
1
的结点（设为
n1
），那么总结点
n=n0+n1+n2
。
同时，对于每一个结点来说都是由其父结点分支表示的，假设树中分枝数为
B
，那么总结点数
n=B+1
。而分枝数是可以通过
n1
和
n2
表示的，即
B=n1+2
n2
。所以，
n
用另外一种方式表示为
n=n1+2
n2+1
。两种方式得到的
n
值组成一个方程组，就可以得出
n0=n2+1
。
二叉树还可以继续分类，衍生出满二叉树和完全二叉树。
完全二叉树：
如果二叉树中除去最后一层节点为满二叉树，且最后一层的结点依次从左到右分布，则此二叉树被称为完全二叉树。
完全二叉树除了具有普通二叉树的性质，它自身也具有一些独特的性质，比如说，
n
个结点的完全二叉
树的深度为
⌊
log2n
⌋
+1
。
对于任意一个完全二叉树来说，如果将含有的结点按照层次从左到右依次标号，对于任意一个结点
i
，完全二叉树还有以下几个结论成立：
1.
当
i>1
时，父亲结点为结点
[i/2]
。（
i=1
时，表示的是根结点，无父亲结点）
2.
如果
2i>n
（总结点的个数） ，则结点
i
肯定没有左孩子（为叶子结点）；否则其左孩子是结点
2i。
3.
如果
2i+1>n
，则结点
i
肯定没有右孩子；否则右孩子是结点
2i+1
。
满二叉树：
如果二叉树中除了叶子结点，每个结点的度都为
2
，则此二叉树称为满二叉树。
满二叉树除了满足普通二叉树的性质，还具有以下性质：
1.
满二叉树中第
i
层的节点数为
2i-1
个。
2.
深度为
k
的满二叉树必有
2k-1
个节点 ，叶子数为
2k-1
。
3.
满二叉树中不存在度为
1
的节点，每一个分支点中都两棵深度相同的子树，且叶子节点都在最底层。
4.
具有
n
个节点的满二叉树的深度为
log2(n+1)
。
二叉树的顺序存储：
二叉树
的顺序存储，指的是使用顺序表
(
数组
)
存储二叉树。虽然树是非线性存储结构，但也可以用顺序表存储。
需要注意的是，顺序存储只适用于完全二叉树。对于普通的二叉树，必须先将其转化为完全二叉树，才能存储到顺序表中。
满二叉树也是完全二叉树，可以直接用顺序表存储。
一棵普通二叉树转化为完全二叉树的方法很简单，只需要给二叉树额外添加一些结点，就可以把它
"
拼凑
"
成完全二叉树。
所谓顺序存储完全二叉树，就是从树的根结点开始，按照层次将树中的结点逐个存储到数组中。
示例代码入下：
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define Ele int
#define NODENUM 7
typedef Ele bitree[NODENUM];
void initbitree(bitree T){
Ele node;
int i=0;
printf("按照层次从左往右输入树中节点的值，0表示空节点，#表示输入结束：\n");
while(scanf("%d",&node)){
T[i]=node;
i++;
if(i==NODENUM){
break;
}
}
}
Ele parent(bitree T,Ele e){
int i;
if(T[0]==0){
printf("存储的是一个空树。\n");
}else{
if(T[0]==e){
printf("当前节点是根节点，没有双亲节点。\n");
return 0;
}
for(i=1;i<NODENUM;i++){
if(T[i]==e){
return T[(i+1)/2-1];
}
}
printf("二叉树中没有指定节点。\n");
}
return -1;
}
Ele leftchild(bitree T,Ele e){
int i;
if(T[0]==0){
printf("存储的是一颗空树。\n");
}else{
for(i=1;i<NODENUM;i++){
if(T[i==e]){
if(((i+1)*2<NODENUM) && (T[(i+1)*2-1]!=0)){
return T[(i+1)*2-1];
}else{
printf("当前节点没有左孩子。\n");
return 0;
}
}
}
printf("二叉树中没有指定节点。\n");
}
return -1;
}
Ele rightchild(bitree T,Ele e){
int i;
if(T[0]==0){
printf("存储的是一颗空树。\n");
}else{
for(i=1;i<NODENUM;i++){
if(T[i]==e){
if(((i+1)*2+1<NODENUM) && (T[(i+1)*2]!=0)){
return T[(i+1)*2];
}else{
printf("当前节点没有右孩子。\n");
return 0;
}
}
}
printf("二叉树中没有指定的节点。\n");
}
return -1;
}
int main(){
int res;
bitree T={0};
initbitree(T);
res=parent(T,3);
if(res!=0 && res!=-1){
printf("节点3的双亲节点的值为：%d\n",res);
}
res=leftchild(T,2);
if(res!=0 && res!=-1){
printf("节点2的左孩子的值为：%d\n",res);
}
res=rightchild(T,2);
if(res!=0 && res!=-1){
printf("节点2的右孩子的值为：%d\n",res);
}
return 0;
}
结果如下：
二叉树的链式存储：
所谓二叉树的链式存储，其实就是用
链表
存储二叉树，具体的存储方案是：从树的根节点开始，将各个节点及其左右孩子使用链表存储。
采用链式存储二叉树时，树中的结点由
3
部分构成。
指向左孩子节点的指针（
Lchild
）；
节点存储的数据（
data
）；
指向右孩子节点的指针（
Rchild
）；
示例代码如下：
#include<stdio.h>
#include<stdlib.h>
#define Ele int
typedef struct bitnode{
Ele data;
struct bitnode *lchild;
struct bitnode *rchild;
}Bnode,*Btree;
void creatbitree(Btree *T){
*T=(Bnode *)malloc(sizeof(Bnode));
(*T)->data=1;
(*T)->lchild=(Bnode *)malloc(sizeof(Bnode));
(*T)->lchild->data=2;
(*T)->rchild=(Bnode *)malloc(sizeof(Bnode));
(*T)->rchild->data=3;
(*T)->rchild->lchild=NULL;
(*T)->rchild->rchild=NULL;
(*T)->lchild->lchild=(Bnode *)malloc(sizeof(Bnode));
(*T)->lchild->lchild->data=4;
(*T)->lchild->rchild=NULL;
(*T)->lchild->lchild->lchild=NULL;
(*T)->lchild->lchild->rchild=NULL;
}
void destorybitree(Btree T){
if(T){
destorybitree(T->lchild);
destorybitree(T->rchild);
free(T);
}
}
int main(){
Btree tree;
creatbitree(&tree);
printf("根节点的左孩子节点为：%d\n",tree->lchild->data);
printf("根节点的右孩子节点为：%d\n",tree->rchild->data);
destorybitree(tree);
return 0;
}
运行结果如下：
2.排序：
概念：排序是计算机内经常进行的一种操作，其目的是将一组
“
无序
”
的记录序列调整为
“
有序
”
的记录序列。分
内部排序和外部排序，若整
个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，
若参加排序的记录数量很大，整个序
列的排序过程不可能在内存中
完成，则称此类排序问题为外部排
序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。
冒泡排序：
冒泡排序（
Bubble Sort
），是一种
计算机科学
领域的较简单的
排序算法
。它重复地走访过要排序的元素列，依次比较两个相邻的
元素
，如果顺序（如从大到小、首字母从
Z
到
A
）
错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素
列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢
“
浮
”
到数列的顶端（升序或降序排列），就如同
碳酸饮料中
二氧化碳
的气泡最终会上浮到顶端一样，故名
“
冒
泡排序
”
。
选择排序：
选择排序（
Selection sort
）是一种简单直观的
排序算法
。它的工作原理是：第一次从待排序的
数据元素
中选出最小（或最大）的一个元素，存放在序列的起始位
置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，
直到全部待排序的数据元素的个数为零。选择
排序
是不稳定的排序方法
示例如下：
#include<stdio.h>
#include<stdlib.h>
void px(int fs[],int n){
int s,m,min,temp;
for(s=0;s<n;s++){
min=s;
for(m=s+1;m<n;m++){
if(fs[min]>fs[m]){
min=m;
}
}
if(min!=s){
temp=fs[min];
fs[min]=fs[s];
fs[s]=temp;
}
}
}
int main(){
int fs[6]={89,52,36,74,52,75};
px(fs,6);
for(int s=0;s<6;s++){
printf("%d ",fs[s]);
}
printf("\n");
return 0;
}
运行结果如下：
插入排序：
插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法。插入排序是一种最简单的
排序
方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而生成一个新的、记
录数增
1
的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素进行扫描，
内层循环对当前元素前面有序表进行待插入位置查找，并进行移动 。
精髓：将无序序列插入到有序序列中
满足以下条件，效率最高：
①如果序列基本有序，
②插入排序的时候，数据序列比较少
插入排序是指在待排序的元素中，假设前面
n-1(
其中
n>=2)
个数已经是排好顺序的，现将第
n
个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第
n
个数的这个序列也是排好顺序的。按照此
法对所有元素进行插入，直到整个序列排为有序的过程，称为插入排序。
示例如下：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <sys/timeb.h>
#define SIZE 5
long get_sys_time(void)
{
struct timeb tb;
ftime(&tb);
return tb.time*1000+tb.millitm;
}
void print(int arr[],int n)
{
for(int i=0;i<SIZE;i++)
{
printf("%d ",arr[i]);
}
printf("\n");
}
void insert_sort(int arr[], int n)
{
for(int i=1;i<n; i++)
{
if(arr[i]<arr[i-1])
{
int temp=arr[i];
int j;
for(j=i-1; j>=0;j--)
{
if(temp<arr[j])
{
arr[j+1]=arr[j];
}
else
{
break；
}
}
arr[j+1]=temp;
}
}
}
int main()
{
int arr[SIZE]={0};
srand((unsigned int)time(NULL));
for(int i=0;i<SIZE;i++)
{
arr[i]= rand()%1000+1;
}
print(arr,SIZE);
long t_start=get_sys_time();
insert_sort(arr,SIZE);
long t_end=get_sys_time();
printf("\n 运行时间:%ld\n",t_end-t_start);
print(arr,SIZE);
return 0;
}快速排序：
快速排序（
Quicksort
），计算机科学词汇，适用领域
Pascal
，
c++
等语言，是对
冒泡排序
算法的一种改进。
快速排序算法通过多次比较和交换来实现排序，其排序流程如下：
(1)
首先设定一个分界值，通过该分界值将数组分成左右两部分。
(2)
将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。
(3)
然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
(4)
重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了
示例如下：
#include<stdio.h>
#include<stdlib.h>
void px(int fs[],int start,int end){
int i=start;
int j=end;
int temp=fs[start];
if(i<j){
while(i<j){
while(i<j && fs[j]>=temp){
j--;
}
if(i<j){
fs[i]=fs[j];
i++;
}
while(i<j && fs[i]<temp){
i++;
}
if(i<j){
fs[j]=fs[i];
j--;
}
}
fs[i]=temp;
px(fs,start,i-1);
px(fs,i+1,end);
}
}
int main(){
int fs[6]={56,89,21,58,33,45};
int s;
px(fs,0,5);
for(s=0;s<6;s++){
printf("%d ",fs[s]);
}
printf("\n");
return 0;
}
运行结果如下：
206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
