排序算法总结（一）

冒泡排序：

原理：

     两两比较相邻记录的排序码，若发生逆序，则交换；有两种方式进行冒泡，一种是先把小的冒泡到前边去，另

一种是把大的元素冒泡到后边。

优化：

    若初始序列就是排序好的，对于冒泡排序任然是还要比较O(N^2)次，但无交换次数。例如有一个无序数列（2，1，3，4，5，6，7，8，9，10）从第一次循环交换后的操作，可以说都是没必要的。所以，这些操作就是我们需要优化的地方。

那么如何优化？

   通过观察可以看到，造成没必要的操作主要原因是后面8个数的顺序都已经是有序。所以，我们可以通过设置一个标记变量，标记数列中的数是否在循环结束前就已经排好序。

代码：

[cpp] view plain copy

 print?

1. #include <stdio.h>  
2. void swap(int *a, int *b);  
3. int main()  
4. {  
5.     int    array[10] = {2, 1, 3, 4, 5, 6, 7, 8, 9, 10};  
6.     int    i, j;  
7.     int    flag = 1;   //设置标记变量  
8.     for (i = 0; i < 10 && flag; i++)  
9.     {  
10.         flag = 0;      //只要flag在下一次外循环条件检测的时候值为0，就说明已经排好序，不用继续循环  
11.         for (j = 9; j > i; j--)  
12.         {  
13.             if (array[j] < array[j-1])  
14.             {  
15.                 swap(&array[j], &array[j-1]);  
16.                 flag = 1;   //如果有交换，就将标记变量赋1  
17.             }  
18.         }  
19.     }  
20.   
21.     for (i = 0; i < 10; i++)  
22.     {  
23.         printf("%d\n", array[i]);  
24.     }  
25.     return    0;  
26. }  
27. void swap(int *a, int *b)  
28. {  
29.     int    temp;  
30.     temp = *a;  
31.       *a = *b;  
32.       *b = temp;  
33. }  

根据优化过的代码，当最好情况的时候，冒泡排序的时间复杂度是O(n)

插入排序：

原理：

    依次选择一个待排序的数据，插入到前边已经排好序的序列中。

性能：

    时间复杂度O(N^2)，空间复杂度为O（1）。算法是稳定的，比较次数与交换次数都与初始序列有关。

优化：

    直接插入排序每次往前插入的时候，是按顺序一次往前找，可以在这里进行优化，往前找合适的插入位置时采用二分查找的方式，即折半插入。

    折半插入排序相对直接插入排序而言：平均性能更快，时间复杂度降至O（NlogN），排序是稳定的，但排序的比较次数与初始序列无关，总是需要foor(log(i)+1)次比较。

使用场景：   当数据基本有序时，采用插入排序可以减少数据的交换和移动次数，进而提升排序效率。

#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
  
void insert_sort(int value[], int length)  
{  
    int i = 0;  
    int j = 0;  
    int temp;  
      
    for(i = 1; i < length; i ++)  
    {  
		if(value[i]<value[i-1])//如果发生逆序，往前插入
		{
			int temp = value[i];  
			int low=0;
			int high=i-1;
			int mid;
			while(low<=high)
			{
				mid=(low+high)/2;
				if(temp<value[mid])
				{
					high=mid-1;
				}
				else
				{
					low=mid+1;
				}
			}
			for(j = i; j >= low; j--)  
			{  
					value[j] = value[j-1];  		
			}
			value[low] = temp;  
		}
    }  
  
}  
  
int main()  
{  
    int value[7] = {7,9,15,25,47,26,5};  
    int i = 0;  
    int length = 7;  
  
    printf("Before:\n");  
  
    for(i = 0; i < length; i++)  
    {  
        if(i == length -1)  
        {  
            printf("%d\n", value[i]);  
        }  
        else  
        {  
            printf("%d\t", value[i]);  
        }  
    }  
  
    insert_sort(value, length);  
    printf("After:\n");  
  
    for(i = 0; i < length; i++)  
    {  
        if(i == length -1)  
        {  
            printf("%d\n", value[i]);  
        }  
        else  
        {  
            printf("%d\t", value[i]);  
        }  
    }  
  
    return 0;  
}  

希尔排序：

原理：  插入排序的改进版，是基于插入排序的以下两点性质而提出的改进方法：

            1.插入排序对几乎已排好的数据操作时，效率很高，可以达到线性排序的效率。

            2.但插入排序在每次往前插入时只能将数据移动一位，效率比较低。

所以，希尔排序的思想就是：

            1.先是取一个合适的gap

             2.缩小间隔gap，例如去gap=ceil(gap/2),重复上述子序列划分和排序

            3.直到，最后gap=1时，将所有的元素放在同一个序列中进行插入排序为止。

性能：

       开始时，gap取值较大，子序列中的元素较少，排序速度较快，克服了直接插入排序的缺点；其次，gap值逐渐变小，虽然子序列元素逐渐变多，但大多数元素己经基本有序，所以继承了直接插入排序的优点，能以近线行的速度排好序。

void shell_sort(int value[], int length)  
{  
    int i=0;
	int gap;
  for(gap=length/2;gap>0;gap/=2)
  {
	  for(i=0;i<length;i=i+gap)
	  {
		  int temp=value[i];
		  int j;
		  for(j=i;j>=gap&&temp<value[j-gap];j-=gap)
		  {
			  value[j]=value[j-gap];
		  }
		  value[j]=temp;
	  }
  }
}