几种排序算法整理

1. 关于冒泡排序算法：

Bubble Sort：

冒泡法排序时，用两个for循环实现；

循环开始时，首先用第一个元素与第二个元素比较，根据升序或是降序的条件来决定是否要交换位置；不管是否交换了位置，内循环都自增一次，然后继续进行根据条件交换位置，直到内循环达到了N-1-i；此时外循环自增一次，外循环的结束条件是N-1次；

算法实现：

经典方法：

#include <stdio.h>

#define N 10

int main (void)

{

int i, j;

int array[N] = {9, 2, 5, 0, 7, 6, 1, 3, 4, 8};

for(i = 0 ; i < N ; i++)

{

for(j = 0 ; j < N - 1 - i ; j++)

{

if(array[j] < array[j+1])

{

temp = array[j];

array[j] = array[j+1];

array[j+1] = temp;

}

}

}

return 0;

}

优化冒泡：

#include <stdio.h>

#define N 10

int main (void) 

{

int i, j;

int array[N] = {9, 2, 5, 0, 7, 6, 1, 3, 4, 8};

for(i = 0 ; i < N-1 ; i++)              //就是这一句优化了，少比较了一次；

{

for(j = N-1 ; j > i ; j--)

{

if(array[j] < array[j-1])

{

temp = array[j];

array[j] = array[j-1];

array[j-1] = temp;

}

}

}

return 0;

}

2. 关于选择排序算法：

Selection Sort：

选择排序也是用两个for循环实现；

外循环由有多少要排的数字决定(N)；

内循环表示在剩余的元素中找到值最小的那个元素（默认是升序排序）；

算法实现：

#include <stdio.h>

#define N 10

int main (void)

{

int i, j, min, temp;

int array[N] = {9, 2, 5, 0, 7, 6, 1, 3, 4, 8};

for(i = 0 ; i < N ; i++)

{

for(min = i , j = i + 1 ; j < N ; j++)

{

if(array[j] < min)

min = j;

}

if(min != i) //这一句可有可无，但是可以在第一个元素就是最小值时减少一次交换

{

temp = array[i];

array[i] = array[min];

array[min] = temp;

}

}

return 0;

}

 

3. 关于插入排序算法：

Insertion Sort：

插入排序同样需要两个for循环；

首先外循环从第二个元素开始，将第二个元素与第一个元素比较，如果第二个元素较小，则交换排序；然后外循环自增一次；

内循环主要是将要进行排序的元素与已经排好序的序列比较，将比要比较的元素大的元素依次后移；

最后将之前保存的元素插入相应的位置即可；

算法实现：

#include <stdio.h>

#define N 10

int main (void)

{

int i, j, temp;

int array[N] = {9, 2, 5, 0, 7, 6, 1, 3, 4, 8};

for(i = 1 ; i < N ; i++)

{

if(array[i] < array[i-1])

{

temp = array[i];      //将比较的数字保存起来;

for(j = i-1 ; temp < array[j] ; j--)

array[j+1] = array[j];       //将已经排好序的序列后移;

array[j+1] = temp;

}

}

return 0;

}

4. 关于快速排序算法：

Quick Sort：

快速排序可以用递归的思想实现；

使用递归时，需要特别注意递归退出的条件；

需要两个索引，一个指向第一个元素，另一个指向最后一个元素，并且每一次划分的第一个元素称为一个key；

首先从后向前搜索，如果j指向的值小于key，那么交换i和j对应的元素，然后索引j往前移一位；

然后从前向后搜索，如果i指向的值大于key，那么交换i和j对应的元素，然后索引i向后移一位；

当i等于j的时候，循环结束。

算法实现：

void QuickSort(int array[], int n)

{

if(n <= 1)         //递归退出的条件;

return;

int i =0 , j = n - 1;

int key = array[0];

int index = 0;

int temp;

while(i < j)

{  

while(i < j && array[j] > key)         //从后向前搜索;

j--;

if(j == i)

break;

else

{

temp = array[i];

array[i] = array[j];

array[j] = temp;

index = j;

}

while(i < j && array[i] < key)          //从前向后搜索;

i++;

if(i == j)

break;

else

{

temp = array[i];

array[i] = array[j];

array[j] = temp;

index = i;

}             

}     

QuickSort(array, index);

QuickSort(array + index + 1, n - 1 - index);

}