标签：优化 swa 数据结构 希尔排序 最小值 算法分析 mina 直接 有序
交换排序类：冒泡排序、快速排序
选择排序类：简单选择排序、堆排序
插入排序类：直接插入排序、希尔排序
冒泡排序（Bubble Sort），排序的基本思想为两两比较小相邻数据的关键字，如果顺序为反则进行交换，直到没有反序的记录为止。
冒泡排序有多种变化，其三种不同实现的代码如下：
//OS：Win | Terminal：Cmder | Editor：Atom | Language：c
void Swap(int *a , int *b){
int temp = *a;
*a = *b;
*b = temp;
}
//最容易的排序，从第一个元素开始向后与每一个元素进行比较，交换得到最小的元素，放在第i个位置
//这样排序进行较多次无用的比较，当然，这并不是所谓的冒泡排序
void SimpleBubble(int array[] , int length){
for(int i = 0 ; i < length ; i++){
for(int j = i+1 ; j < length ; j++){
if(array[i] > array[j]){
Swap(&array[i],&array[j]);
}
}
}
}
//从第一个位置开始，由下往上两两元素进行比较，判断并交换得到最小值
//这样排序依次循环确定第i个位置的元素
void LittleBubble(int array[] ,int length){
for(int i =0 ; i < length ; i++){
for(int j = length -1 ; j > i ;j --){
if(array[j] < array[j-1]){
Swap(&array[j],&array[j-1]);
}
}
}
}
//增加标志位isSwap来表示是否存在反序或者是否进行过交换操作
//直到序列没有反序记录为止
void BubbleSort(int array[] , int length){
int isSwap = 1;
for(int i = 0 ; i < length ; i ++){
if(isSwap){
isSwap = 0;
for(int j = length -1 ; j > i ; j --){
if(array[j] < array[j-1]){
Swap(&array[j],&array[j-1]);
isSwap = 1;
}
}
}
}
}
void Print(int array[] , int length){
for (int i = 0 ; i < length ;i++){
printf(" %d",array[i]);
}
}
int main(){
int array[] = {6,5,3,1,0,2,9,8,4,7};
BubbleSort(array,10);
Print(array,10);
return 0;
}简单选择排序（Simple Selection Sort），基本思想是：标记第i个元素为最小值下标min开始向后进行遍历比较，不断更新最小值下标min,结束该次循环后判断min是否改变，若改变即交换i位置元素及min位置的最小元素。
void SelectSort(int array[] , int length){
int min;
for(int i = 0 ; i <length ; i++){
min = i ; //Notice1：以第一个元素为最小开始向后遍历比较
for(int j = i+1 ; j < length ; j++){ //Notice2:j从i+1开始向后遍历
if(array[j] < array[min]){ //Notice3:每次都是array[j]与array[min]进行比较，来确定和更新最小值所在下标
min = j;
}
}
if(min != i){
Swap(&array[i] ,&array[min]);
}
}
}
直接插入排序(Straight Insertion Sort)是最简单的排序算法之一，主要思想是保证位置0到第i-1位置上的元素为已排序状态，即插入排序利用这样的事实，从i位置循环进行排序。
void InsertionSort(int array[] , int length ){
int i,j,temp;
//Notice1:开始以第一个数据为有序序列，从第二个数据开始排序
for(i = 1 ; i <length ; i++){
if(array[i] < array[i-1]){ //Notice2:当当前数据大于前一个时，开始向前插入
temp = array[i]; //保存此时的值，为前方较大元素空出位置
for(j = i -1 ; j>=0 && array[j] > temp ; j--){ //向前循环直至下标小于0，或者值比当前值更小
array[j+1] = array[j]; //依次后移
}
array[j+1] = temp; //此时j位置的元素小于当前值，所以插入其后一位j+1即可
}
}
}
希尔排序（Shell Sort）是冲破二次时间屏障的第一批算法之一。主要思想是：通过比较一定间隔的元素来工作；各趟比较所用的距离（希尔增量）随着算法的进行而逐渐减小，直到比较相元素的最后一趟排序为止。因此，希尔排序也称为缩小增量排序。
void ShellSort(int array[] , int length){
int i,j,temp,gap;
int judgeCount = 0, changeCount = 0;
//Notice1:设置希尔增量序列初始值 gap = length/2 ，一直循环值gap=1进行最后一次插入排序
for(gap = length/2 ; gap >0 ; gap /=2){
//Notice2:内层嵌套一个直接插入循环
for(i = gap ; i < length ; i++ ){
judgeCount++;
if(array[i] < array[i - gap]){
temp = array[i];
for(j = i - gap ; j >= 0 && array[j] > temp ; j -=gap){
array[j+gap] = array[j];
changeCount++;
}
array[j+gap] = temp;
}
}
}
printf("Judge Count : %d ,Change Count : %d .\n", judgeCount,changeCount);
}
堆排序（Heap Sort）是一个非常稳定的算法，排序平均使用的比较只比最坏情况界指出的略少。
void AdjustHeap(int array[] , int i , int length){
//Notice2:保存开始节点的值为temp，减少直接交换的次数
int temp = array[i];
for(int j = i*2 +1 ; j <length ; j = j*2+1){
if(j+1 < length && array[j] < array[j+1])
j++;
if(array[j] < temp ) //Notice3:循环对temp中保存的值进行比较
break;
array[i] = array[j];
i = j;
}
array[i] = temp; //Notice4:最后在temp合适的位置上进行赋值放置
}
void HeapSort(int array[] ,int length){
//Notice1:首先从最后一个非页子节点开始，由右向左、由下至上开始进行最大堆的构造
for(int i = length/2 ; i >= 0 ; i --){
AdjustHeap(array , i ,length);
}
for(int i = length -1 ; i > 0 ; i --){
Swap(&array[0],&array[i]);
AdjustHeap(array, 0, i );
}
}
快速排序（Quick Sort）是在实践中最快的已知排序算法，平均运行时间是O(N log N)。快速排序之所以快是因为其精炼的、高度优化的内部循环。最坏情况的性能为O(N2)，如今高度优化后的快速排序简单易懂并且不难证明。
和归并排序一样，快速排序也是一种分治的递归算法。
将数组array进行快速排序QuickSort的基本算法由以下简单的四步组成：
书籍：
数据结构与算法分析、大话数据结构
标签：优化 swa 数据结构 希尔排序 最小值 算法分析 mina 直接 有序
原文地址：https://www.cnblogs.com/sylvan/p/9383107.html
