排序算法总结

1.冒泡排序：

思路：一个数组中，从a[0]到a[n] 遍历的过程中，将此轮最大(最小)的数放在a[n]位置,

下一轮从之前元素的下一个在进行一次遍历，将最大(最小)的数放在a[n]处.

代码：

void Bubble(in a[],int length)

{

for(int i=0;i

{

for(int j=1;j

{

if(a[j-1]>a[j])

{

swap(a[j-1],a[j]);
   }
 }
}

}

 

2.改进冒泡排序：

思路：在原始冒泡是方式中，判断是否交换，对交换步骤进行了控制，设置了标志量。

代码：

int flag = 0;

void Bubble(in a[],int length)

{

for(int i=0;i

{

flag =1;

for(int j=1;j

{

if(a[j-1]>a[j])

{

flag = 0;

swap(a[j-1],a[j]);
   }
 }
}

}

3.插入排序

思路：将数组a[0]作为一个已经有序的数组，从第二个元素开始，判断大小规则，所做操作：将将当前元素保存到一个临时变量中，然后通过一个循环，条件是当前下标大于等于0，而且临时变量中比他要小(与大小规则一致),就进行交换，否则就将临时变量给当前数组比较元素。

 

 

代码：

void insert_sort(int a[],int length)

{

  intj=0;

  for(inti=1;i

{

  if(a[i]

{

int temp = a[i];

for(j=i-1;j>=0&&temp

{

  a[j+1] = a[j];

}

a[j+1] = temp;

}

  }

}

4.选择排序

思路：一个数组，从开始遍历，假设最小的数下标为0，然后将这个下标暂时保留min，然后从下一个元素进行遍历，如果当前元素小于标记的最小数，则将把这时最小的下标给min,

当内循环结束，判断最小值min !=i; 则交换元素。

代码：

void select_sort(int a[],int length)

{

 for(int i=0;i

{

  Int min = I;

  For(int j=i+1;j

{

  If(a[min]>a[j])

{

min = j;
}

}

If(min!=i)

{
swap(&a[min],&a[i]);

}
}

 

 

}

5.希尔排序

思路：对数组进行分组，其实，将数组中小标跳跃似地遍历，再配合插入排序的规则，就可以了。分组增量 = 分组增量/3 +1;

代码：

void shell(int a[],int length)

{

  Int increase = length;

  IntI,j,k;

  do{

increase = increase/3+1;

for(i = 0;i

{

 for(j=i+increase;j

{

  if(a[j]

{

  Int temp = a[j];

  For(k =j-increase;k>=0&&temp

{

         a[k+ increase] = a[k];

}

a[k+increase] = temp;

}

}

}

} while(increase >1);

6.快速排序

思路：将数组开始和结束做标记，暂且将最开始元素保存起来temp，比较满足,后坐标向前移动，前坐标，向后移动。不满足条件a[j]给a[i]，之后递归解决问题。

void QuickSort(int arr[], int start,intend)

{

         inti = start;

         intj = end;

         inttemp = arr[start];

         if(i

                  

                   while(i

                            while(i < j && temp <=arr[j]){

                                     j--;

                            }

                            if(i

                                     arr[i]= arr[j];

                                     i++;

                            }

                            while(i arr[i]){

                                     i++;

                            }

                            if(i

                                     arr[j]= arr[i];

                                     j--;

                            }

                   }

           arr[i] = temp;

                            QuickSort(arr,start, i - 1);

                            QuickSort(arr,i+ 1,end); 

         }

}

7.堆排序

思路：借用堆数据结构，-一个二叉树，父节点要比孩子节点要大（小）.

void HeapAdjust(int arr[], int index, intlen){

 

         //先保存当前结点的下标

         intmax = index;

         //保存左右孩子的数组下标

         intlchild = index * 2 + 1;

         intrchild = index * 2 + 2;

 

         if(lchild < len && arr[lchild] > arr[max]){

                   max= lchild;

         }

 

         if(rchild < len && arr[rchild] > arr[max]){

                   max= rchild;

         }

 

         if(max != index){

                   //交换两个结点

                   MySwap(arr,max, index);

                   HeapAdjust(arr,max, len);

         }

}

 

//堆排序

void HeapSort(int myArr[], int len){

 

         //初始化堆

         for(int i = len / 2 - 1; i >= 0; i--){

                   HeapAdjust(myArr,i, len);

         }

 

         //交换堆顶元素和最后一个元素

         for(int i = len - 1; i >= 0; i--){

                   MySwap(myArr,0, i);

                   HeapAdjust(myArr,0, i);

         }

 

}

 

8.并归排序

思路：将数组分为两段，

void Merge(int arr[],int start,int end,int mid,int*temp){

         inti_start = start;

         inti_end = mid;

         intj_start = mid+1;

         intj_end = end;

         intlength = 0;

         while(i_start <= i_end && j_start <= j_end){

 

                   if(arr[i_start] < arr[j_start]){

                            temp[length]= arr[i_start];

                            length++;

                            i_start++;

                   }

                   else{

                            temp[length]= arr[j_start];

                            j_start++;

                            length++;

                   }

         }

 

         //i这个序列

         while(i_start <= i_end){

                   temp[length]= arr[i_start];

                   i_start++;

                   length++;

         }

 

         //j序列

         while(j_start <= j_end){

                   temp[length]= arr[j_start];

                   length++;

                   j_start++;

         }

 

         //辅助空间数据覆盖原空间

         for(int i = 0; i < length; i++){

                   arr[start+ i] = temp[i];

         }

}

void MergeSort(int arr[],int start,intend,int *temp){

         if(start>=end){

                   return;

         }

         intmid = (start + end) / 2;

         MergeSort(arr,start,mid,temp);

         MergeSort(arr,mid+1, end, temp);

         Merge(arr,start,end,mid,temp);

         //13 3 4 5 5 6 6 7 7 8 8 8 9 9 9 10 23 23 42 81 87 90 97

}