目录

一、二叉树补充——层序遍历：

0、层序遍历

1、通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树：

2、二叉树销毁void BinaryTreeDestory(BTNode** root);

3、判断二叉树是否是完全二叉树

bool BinaryTreeComplete(BTNode* root);

二、排序排序的概念及其运用

2.1排序的概念

2.2常见的排序算法

三、常见排序算法的实现

3.1 插入排序

3.1.1基本思想

3.1.2直接插入排序：

3.2 希尔排序( 缩小增量排序 )

3.2.1基本思想

3.3选择排序 —直接选择排序、堆排序

3.3.1基本思想：

3.3.2直接选择排序:

3.3.3 堆排序

一、二叉树补充——层序遍历：

0、层序遍历

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在 层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层 上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

void LevelOrder(BTNode* root)
{Queue q;QueueInit(&q);if (root){QueuePush(&q, root);}while (!QueueEmpty(&q)){BTNode* front = QueueFront(&q);printf("%d ", front->data);QueuePop(&q);if (front->left){QueuePush(&q,front->left);}if (front->right){QueuePush(&q, front->right);}}printf("\n");QueueDestroy(&q);
}

1、通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树：

二叉树遍历_牛客题霸_牛客网 (nowcoder.com)https://www.nowcoder.com/practice/4b91205483694f449f94c179883c1fef?tpId=60&&tqId=29483&rp=1&ru=/activity/oj&qru=/ta/tsing-kaoyan/question-ranking

#include 
#include
#include
typedef char BTDataType;
typedef struct BinaryTreeNode
{BTDataType data;struct BinaryTreeNode* left;struct BinaryTreeNode* right;
}BTNode;BTNode* BuyNode(BTDataType x)
{BTNode* node = (BTNode*)malloc(sizeof(BTNode));assert(node);node->data = x;node->left = NULL;node->right = NULL;return node;
}void InOrder(BTNode* root)
{if (root == NULL){return;}InOrder(root->left);printf("%c ", root->data);InOrder(root->right);
}BTNode* CreateTree(char* str ,int*pi)
{if(str[*pi] == '#'){(*pi)++;return NULL;}BTNode* root = BuyNode(str[(*pi)++]);root->left = CreateTree(str,pi);root->right= CreateTree(str,pi);return root;
}int main()
{char str[100];scanf("%s",str);int i = 0;BTNode* root = CreateTree(str,&i);InOrder(root);return 0;
}

2、二叉树销毁
void BinaryTreeDestory(BTNode** root);

// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{if (root == NULL){return;}BinaryTreeDestory(root->left);BinaryTreeDestory(root->right);free(root);
}

3、判断二叉树是否是完全二叉树

bool BinaryTreeComplete(BTNode* root);

bool BinaryTreeComplete(BTNode* root)
{Queue q;QueueInit(&q);if (root){QueuePush(&q, root);}while (!QueueEmpty(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);if (front){QueuePush(&q, front->left);QueuePush(&q, front->right);}else{//遇到空以后，跳出层序遍历break;}}//如果后面全是空则是完全二叉树//如果后面还有非空，则不是完全二叉树while (!QueueEmpty(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);if (front){QueueDestroy(&q);return false;}}QueueDestroy(&q);return true;
}

二、排序排序的概念及其运用

2.1排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

2.2常见的排序算法

三、常见排序算法的实现

3.1 插入排序

3.1.1基本思想

直接插入排序是一种简单的插入排序法，其基本思想是：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为 止，得到一个新的有序序列 。

实际中我们玩扑克牌时，就用了插入排序的思想。

3.1.2直接插入排序：

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与 array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

//插入排序
void InsertSort(int* a, int n)
{for (int i = 0; i < n - 1; i++){//[0,end]有序，把end+1位置的值插入，保持有序int end = i; int tmp = a[end + 1];while (end >= 0){if (tmp < a[end]){a[end + 1] = a[end];--end;}else{break;}}a[end + 1] = tmp;}
}

直接插入排序的特性总结：

• 1. 元素集合越接近有序，直接插入排序算法的时间效率越高
• 2. 时间复杂度：O(N^2)
• 3. 空间复杂度：O(1)，它是一种稳定的排序算法
• 4. 稳定性：稳定

3.2 希尔排序( 缩小增量排序 )

3.2.1基本思想

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工 作。当到达=1时，所有记录在统一组内排好序。

void ShellSort(int* a, int n)
{//gap > 1 时，是预排序//gap 最后一次等于一，是直接插入排序int gap = n;while (gap > 1){gap = gap / 3 + 1;for (int i = 0; i < n - gap; ++i){int end = i;int tmp = a[end + gap];while (end >= 0){if (tmp < a[end]){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = tmp;}}
}

• 排升序，gap越大，大的数更快到后面，小的数可以更快到前面，但是越不接近有序
• 排升序，gap越小，越接近有序
• 当gap == 1，就是直接插入排序

 希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。

2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书本中给出的希尔排序的时间复杂度都不固定

                                《数据结构(C语言版)》--- 严蔚敏

                《数据结构-用面相对象方法与C++描述》--- 殷人昆

 4. 稳定性：不稳定

3.3选择排序 —直接选择排序、堆排序

3.3.1基本思想：

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的 数据元素排完 。

3.3.2直接选择排序:

• 在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素
• 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
• 在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

//选择排序
void SelectSort(int* a, int n)
{assert(a);int begin = 0,end = n - 1;while (begin < end){int mini = begin, maxi = begin;for (int i = begin + 1; i <= end; ++i){if (a[i] < a[mini]){mini = i;}if (a[i] > a[maxi]){maxi = i;}}swap(&a[begin], &a[mini]);if (begin == maxi){maxi = mini;}swap(&a[end], &a[maxi]);++begin;--end;}
}

直接选择排序的特性总结：

1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用

2. 时间复杂度：O(N^2)

3. 空间复杂度：O(1)

4. 稳定性：不稳定

3.3.3 堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

void AdjustDown(int* a, int size, int parent)
{int child = parent * 2 + 1;while (child < size){//if (child + 1 < size && a[child + 1] < a[child])if (child + 1 < size && a[child + 1] > a[child]){child++;}//if (a[child] < a[parent])if (a[child] > a[parent]){swap(&a[parent], &a[child]);parent = child;child = parent * 2 + 1;}else{break;}}}void HeapSort(int* a, int n)
{//建堆方式 1//从第二层第一个节点，向上调整//for (int i = 1; i < n; ++i)//{//	AdjustUp(a, i);//}//建堆方式 2//从第一个非叶子节点，向下调整//向下调整的前提，左右子树必须是堆for (int i = (n - 2) / 2; i >= 0; i--){AdjustDown(a, n, i);}// O(N*log N)int end = n - 1;while (end > 0){swap(&a[0], &a[end]);AdjustDown(a, end, 0);end--;}

直接选择排序的特性总结：

1. 堆排序使用堆来选数，效率就高了很多。

2. 时间复杂度：O(N*logN)

3. 空间复杂度：O(1)

4. 稳定性：不稳定