数据结构(排序算法：基本思想、代码实现)

一、冒泡排序

如果已经全部排序，所需的关键字比较次数[n-1]和记录移动次数[0]均达到最小值，时间复杂度O(n)

如果全部反序,所需的关键字比较次数[n(n-1)/2]和记录移动次数[3*n*(n-1)/2]均达到最大值，时间复杂度O(n^2)

基本思想：

1、第一个数和第二个数比较，如果第一个比第二个大，交换位置，第二个和第三个比较，重复，第一次比较N-1次

2、重复N-i次，每次把最大的数放在最后

public class BubbleSort
{
    public void sort(int[] a)
    {
        int temp = 0;
        for (int i = a.length - 1; i > 0; --i)
        {
            for (int j = 0; j < i; ++j)
            {
                if (a[j + 1] < a[j])
                {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }
}

缺点：效率低(需要比较n*(n-1)/2次)

二、选择排序

如果已经全部排序，所需的关键字比较次数[n-1]和记录移动次数[0]均达到最小值，时间复杂度O(n)

如果全部反序,所需的关键字比较次数[n(n-1)/2]和记录移动次数[n]均达到最大值，时间复杂度O(n^2)

基本思想：

1、每一次循环找出最值，不急着交换，放到每一次循环结束再交换

void SelectSort(RecordType r[], int length)　/*对记录数组r做简单选择排序，length为待排序记录的个数*/
{
    int temp;
    for ( i=0 ; i< length-1 ; i++) //n-1趟排序
    {
        int index=i；　//假设index处对应的数组元素是最小的
        for (int j=i+1 ; j < length ; j++) 　//查找最小记录的位置
            if (r[j].key < r[index].key )
                index=j;
        if ( index!=i) 　//若无序区第一个元素不是无序区中最小元素，则进行交换
        {
            temp     = r[i];
            r[i]     = r[index];
            r[index] = temp;
        }
    }
}

冒泡排序和选择排序比较：

冒泡排序法是两两依次比较，并做交换，交换的次数多。
选择排序法是每次循环找出最值，循环结束后将最值调整到合适位置，交换的次数少。

时间复杂度相同[O(n^2)]，但是换位操作，选择排序是O(n)，冒泡排序是O(n^2/2)

三、快速排序(对冒泡排序的改进)

最佳情况下时间复杂度是 O(nlogn)。但是最坏情况下可能达到O(n^2)

基本思想：

1、先从数列中取出一个数作为基准数
2、分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边
3、再对左右区间重复第二步，直到各区间只有一个数

public static void quickSort(int[] arr){
    qsort(arr, 0, arr.length-1);
}
private static void qsort(int[] arr, int low, int high){
    if (low < high){
        int pivot=partition(arr, low, high);        //将数组分为两部分
        qsort(arr, low, pivot-1);                   //递归排序左子数组
        qsort(arr, pivot+1, high);                  //递归排序右子数组
    }
}
private static int partition(int[] arr, int low, int high){
    int pivot = arr[low];     //枢轴记录
    while (low<high){
        while (low<high && arr[high]>=pivot) --high;
        arr[low]=arr[high];             //交换比枢轴小的记录到左端
        while (low<high && arr[low]<=pivot) ++low;
        arr[high] = arr[low];           //交换比枢轴小的记录到右端
    }
    //扫描完成，枢轴到位
    arr[low] = pivot;
    //返回的是枢轴的位置
    return low;
}

四、插入排序

基本思想：

通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入

    void insertion_sort(int a[], int n)  
    {  
        int i,j,tmp;  
        for (i = 1; i < n; i++) {  
            tmp = a[i];  
            for (j = i - 1; j >= 0 && a[j] > tmp; j--) {  
                a[j+1] = a[j];  
            }  
            a[j+1] = tmp;  
        }  
    }