排序的其他相关知识点和源码分享可以参考之前的博客：
《数据结构与算法基础-学习-30-插入排序之直接插入排序、二分插入排序、希尔排序》
一、交换排序基本思想
两两比较，如果发生逆序则交换位置，直到所有数据记录都排好序为止。
二、冒泡排序基本思想
每趟不断地将数据记录两两比较，并按照升序或降序规则进行交换。
三、冒泡排序算法实现思路
这里的哨兵起的是临时变量的作用，在交换元素时使用。
我们还是以升序为例。
1、第一趟
一共有7个元素，需要比较6次，因为没有8号位。
（1）1小于2，不要交换，继续
（2）2小于8，不要交换，继续
（3）8大于5，需要交换，继续
（4）8大于4，需要交换，继续
（5）8大于6，需要交换，继续
（6）8大于3，需要交换，6次比较完，已经把最大值8放到了最后一位，那下一趟比较时，就不需要比较8了。
2、第二趟
一共有6个元素需要比较，总共需要比较5次，因为7号位的8已经完成排序。
（1）1小于2，不要交换，继续
（2）2小于5，不要交换，继续
（3）5大于4，需要交换，继续
（4）5小于6，不要需要交换，继续
（5）6大于3，需要交换，5次比较完，已经把最大值6放到了最后一位，那下一趟比较时，就不需要比较6，8了。
3、第三趟
一共有5个元素需要比较，总共需要比较4次，因为6和8已经完成排序。
规律都知道了，我们这就快进一些，跳过了一些对比步骤。
1，2，3，4，5都是升序不需要移动。
（1）5大于3，需要交换，4次比较完，已经把最大值5放到了最后一位，那下一趟比较时，就不需要比较5，6，8了。
4、第四趟
一共有4个元素需要比较，总共需要比较4次，因为5，6和8已经完成排序。
规律都知道了，我们这就快进一些，跳过了一些对比步骤。
1，2，4都是升序不需要移动。
（1）4大于3，需要交换，3次比较完，已经把最大值4放到了最后一位，那下一趟比较时，就不需要比较4，5，6，8了。
5、第五趟
一共有4个元素需要比较，总共需要比较3次，因为4，5，6和8已经完成排序。
1，2，3，4就是升序的，没有交换元素，说明序列已经是有序的，排序完成。
四、冒泡排序算法源码
1、BubbleSortSentrySqQueue
Status BubbleSortSentrySqQueue(SqQueue* Queue)
{
JudgeAllNullPointer(Queue);
if (Queue->Flag != INT_TYPE_FLAG)
{
return FailFlag;
}
int* Array = (int*)(Queue->Data);
int SwapFlag = 0;
QueueLenType i;
QueueLenType j;
for (i = 1; i < Queue->SqQueueLen - 1; i++)//长度n，比较（n - 1）趟。
{
SwapFlag = 0;
for (j = 1; j < Queue->SqQueueLen - i; j++)//每趟，比较 （n - 第i趟） 次。找个测试数据更明显，好理解
{
if (Array[j] > Array[j + 1])
{
Array[0] = Array[j + 1];
Array[j + 1] = Array[j];
Array[j] = Array[0];
SwapFlag = 1;
}
}
if (SwapFlag == 0)//如果某一趟不需要进行交换，说明所有元素都是有序的，退出循环。
{
break;
}
}
LogFormat(Debug,"Bubble Sort SqQueue OK.\n");
return SuccessFlag;
}五、冒泡排序算法效率
| 情况 | 时间复杂度 | 是否稳定 |
| 最好 | O(n) | 稳定 |
| 最坏 | O(n^2) | |
| 平均 | O(n^2) |
最好的情况例如冒泡升序排序，数据是升序排列的，只需要比较n-1次即可，不需要移动元素。
最坏的情况例如冒泡升序排序，数据是降序排列的，
（1）需要比较次数为：
长度为n的序列，需要比较n-1次，每次少比一次，直到1为止，可以使用等差求和公式:
((n - 1) + 1) * (n - 1) / 2 = （n^2 - n）/ 2
（2）需要移动次数为：
每比较一次，需要交换一次，交换需要临时变量存放，一共需要三步，所以乘以3。
Array[0] = Array[j + 1];
Array[j + 1] = Array[j];
Array[j] = Array[0];（n^2 - n）/ 2 * 3。
六、冒泡排序Linux环境编译测试
[gbase@czg2 Sort]$ time ./TestSort
2023-9-1--[ Debug ]--Init SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--SqQueue Data :
Data : [ 0 ,10 ,9 ,8 ,7 ,6 ,5 ,4 ,3 ,2 ,1 ]
FrontIndex : 0
RearIndex : 0
SqQueueLen : 11
SqQueueMaxLen : 11
Flag : INT_TYPE_FLAG
2023-9-1--[ Debug ]--Bubble Sort SqQueue OK.
2023-9-1--[ Info ]--Sort Function Elapsed Time : 0 s
2023-9-1--[ Info ]--SqQueue Data :
Data : [ 1 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ]
FrontIndex : 0
RearIndex : 0
SqQueueLen : 11
SqQueueMaxLen : 11
Flag : INT_TYPE_FLAG
2023-9-1--[ Debug ]--Destroy SqQueue OK
real 0m0.002s
user 0m0.000s
sys 0m0.002s七、快速排序基本思想
快速排序是改进的交换排序。
1、任取一个元素为中心（一般是第一个元素）。
2、所有比它小的元素一律前放，比它大的元素一律后放，形成左右两个子表。
3、对各子表重新选择中心元素并依照上述规则调整。
4、直到每个子表的元素只剩下一个。
八、快速排序算法实现思路
这里的哨兵位也是起到存放临时变量的作用的。
1、第一趟
1号位的3作为中间点，存放在哨兵位0中，那Low位置的元素就是空的了。
哨兵位的3和High的1进行比较，3大于1，将High的1填写到Low上，那样High的位置就空出来了。我们开始从Low找。
哨兵位的3和Low的1进行比较，3大于1，在3的左边，不需要移动，Low向右移动。
哨兵位的3和Low的2进行比较，3大于2，在3的左边，不需要移动，Low向右移动。
哨兵位的3和Low的8进行比较，8大于3，在3的右边，需要移动把Low的8移动到High的位置，Low的位置空了，开始High位置和哨兵进行比较，是不是发现了什么，左边有空位了，就去右边找，找，右边空了，就去左边找，很有规律性。
哨兵位的3和High的8进行比较，8大于3，在3的右边，不需要移动，High向左移动。
哨兵位的3和High的6进行比较，6大于3，在3的右边，不需要移动，High向左移动。
哨兵位的3和High的4进行比较，4大于3，在3的右边，不需要移动，High向左移动。
Low和High重合，说明Low左边的都比3小，右边的都比3大，把3填到Low的位置。
Low左边已经排好序了，我们开始排序右边的这些元素。
2、第二趟
还是以第一个Low的位置为中心点，这样Low的位置就空出来了，哨兵和HIgh为的5进行比较，发现比8小，HIgh左移。
哨兵位的5和High的6进行比较，6大于5，在5的右边，不需要移动，High向左移动。
哨兵位的5和High的4进行比较，5大于4，在5的左边，Low填上4，那High的位置就空出来了，我们开始移动Low。
哨兵位的5和Low的4进行比较，5大于4，在3的左边，不需要移动，Low向右移动。
发现Low和High重合，将哨兵填写到Low上，这一段有序了，整个序列就完成了排序。
九、快速排序算法源码
1、QuickSortPartionSentrySqQueue
将Low到High之间元素根据Low为中间值进行分区，返回中间值的最终索引位置。
//返回中间点索引。
QueueLenType QuickSortPartionSentrySqQueue(SqQueue* Queue, QueueLenType Low, QueueLenType High)
{
JudgeAllNullPointer(Queue);
int* Array = (int*)(Queue->Data);
Array[0] = Array[Low];
while (Low < High)
{
while (Low < High && Array[0] <= Array[High])//大于等于中间点的值放右边。
{
High--;
}
Array[Low] = Array[High];
while (Low < High && Array[0] > Array[Low])//小于中间点的值放左边。
{
Low++;
}
Array[High] = Array[Low];
}
Array[Low] = Array[0];
return Low;
}2、QuickSortRecurtionSentrySqQueue
void QuickSortRecurtionSentrySqQueue(SqQueue* Queue, QueueLenType Low, QueueLenType High)
{
JudgeAllNullPointer(Queue);
if (Low >= High)//退出条件，High必须要大于low。
{
return;
}
QueueLenType PivotIndex = QuickSortPartionSentrySqQueue(Queue, Low, High);
QuickSortRecurtionSentrySqQueue(Queue, Low, PivotIndex - 1);
QuickSortRecurtionSentrySqQueue(Queue, PivotIndex + 1, High);
}十、快速排序算法效率
| 情况 | 时间复杂度 | 是否稳定 |
| 最好 | O(n * log2^n) | 不稳定 |
| 最坏 | O(n^2) | |
| 平均 | O(n * log2^n) |
1、快速排序不是原地排序，因为递归方法使用了系统栈，不用递归，需要用用户栈实现。
2、快速排序不适用于对原本有序或基本有序的记录序列进行排序。
3、划分元素的选取是影响时间性能的关键。
4、输入数据次序越乱，所选划分值随机性越好，排序速度越快，快速排序不是自然排序方法。
5、升序快速排序算法使用在倒序排序序列上，会触发最坏的情况，使算法退化为冒泡排序。
十一、快速排序Linux环境编译测试
[gbase@czg2 Sort]$ time ./TestSort
2023-9-1--[ Debug ]--Init SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--Enter SqQueue OK
2023-9-1--[ Debug ]--SqQueue Data :
Data : [ 0 ,10 ,9 ,8 ,7 ,6 ,5 ,4 ,3 ,2 ,1 ]
FrontIndex : 0
RearIndex : 0
SqQueueLen : 11
SqQueueMaxLen : 11
Flag : INT_TYPE_FLAG
2023-9-1--[ Debug ]--Quick Sort Sentry SqQueue OK.
2023-9-1--[ Info ]--Sort Function Elapsed Time : 0 s
2023-9-1--[ Info ]--SqQueue Data :
Data : [ 4 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ]
FrontIndex : 0
RearIndex : 0
SqQueueLen : 11
SqQueueMaxLen : 11
Flag : INT_TYPE_FLAG
2023-9-1--[ Debug ]--Destroy SqQueue OK
real 0m0.002s
user 0m0.000s
sys 0m0.002s
