7大排序算法之冒泡、选择、插入排序

1、冒泡排序

     原理：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

     代码：

/*
 * 冒泡排序
 */
public class BubbleSort {
　　public static void main(String[] args) {
　　　　int[] arr={6,3,8,2,9,1};
　　　　System.out.println("排序前数组为：");
　　　　for(int num:arr){
　　　　　　System.out.print(num+" ");
　　　　}
　　　　for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
　　　　　　　　if(arr[j]>arr[j+1]){
　　　　　　　　　　int temp=arr[j];
　　　　　　　　　　arr[j]=arr[j+1];
　　　　　　　　　　arr[j+1]=temp;
　　　　　　　　}
　　　　　　}
　　　　} 
　　　　System.out.println();
　　　　System.out.println("排序后的数组为：");
 　　　　for(int num:arr){
 　　　　　　System.out.print(num+" ");
 　　　　} 
　　}
 }

2、选择排序

原理：

       第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换；

       第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换；以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。

代码：

//选择排序
public class SelectionSort {
    public static void main(String[] args) {
        int[] arr={1,3,2,45,65,33,12};
        System.out.println("交换之前：");
        for(int num:arr){
            System.out.print(num+" ");
        }        
        //选择排序的优化
        for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;
            for(int j = k + 1; j < arr.length; j++){// 选最小的记录
                if(arr[j] < arr[k]){ 
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if(i != k){  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }    
        }
        System.out.println();
        System.out.println("交换后：");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }

}

3、直接插入排序

1 基本原理

1 核心思想：插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入 ，如此重复，直至完成序列排序。

2 算法分析：

1. 从序列第一个元素开始，该元素可以认为已经被排序

2. 取出下一个元素，设为待插入元素，在已经排序的元素序列中从后向前扫描，如果该元素（已排序）大于待插入元素，将该元素移到下一位置。

3. 重复步骤2，直到找到已排序的元素小于或者等于待排序元素的位置，插入元素

4. 重复2，3步骤，完成排序。

2 实例说明

以一组数据{12，15，9，20，6，31，24} 为例，进行直接插入排序的算法演示：

默认序列第一个元素12 以及被排序。

取下一元素 15 从后往前与已排序序列一次比较，15插入12 之后，已排序序列为[12，15]。

取下一元素9，重复2步骤，将9插12 之前，已排序序列为[9，12，15]。

循环上述操作，直至最后一个元素24，插入合适位置，完成排序。

3 代码实现

// 直接插入排序(C++)

void InsertSort(vector<int> &vi)
{
    for(int i=1;i<vi.size();i++)
    {
        int temp=vi[i];
        int j;
        for(j=i-1;j>=0&&temp<vi[j];j--)
        {
            vi[j+1]=vi[j]；     //将较大元素后移
        }
        vi[j+1]=temp;        //temp插入正确的位置
    }
}

 

算法改进：二分插入排序

二分查找插入排序的原理：是直接插入排序的一个变种，区别是：在有序区中查找新元素插入位置时，为了减少元素比较次数提高效率，采用二分查找算法进行插入位置的确定。

算法分析：

设数组为a[0…n]。

1. 将原序列分成有序区和无序区。a[0…i-1]为有序区，a[i…n] 为无序区。（i从1开始）

2. 从无序区中取出第一个元素，即a[i]，使用二分查找算法在有序区中查找要插入的位置索引j。

3. 将a[j]到a[i-1]的元素后移，并将a[i]赋值给a[j]。

4. 重复步骤2~3，直到无序区元素为0。

// 二分插入排序
void BinInsertSort(vector<int> &vi)
{
    for(int i=1;i<vi.size();i++)
    {
        int left=0;
        int right=i-1;
        int temp=vi[i]
        while(left<=right)
        {
            int mid=(left+right)/2; //二分区域
            if(vi[mid]>temp)
            {
                right=mid-1;       //向左缩小区域
            }
            else
            {
                left=mid+1;        //向右缩小区域
            }
        }
        for(int j=i-1;j>=left;j--)  //vi[left,i-1]的元素整体后移
        {
            vi[j+1]=vi[j];
        }
        vi[left]=temp;
    }
}

 

4 性能分析

1 时间复杂度：

（1）顺序排列时，只需比较(n-1)次，插入排序时间复杂度为O(n)；

（2）逆序排序时，需比较n(n-1)/2次，插入排序时间复杂度为O(n^2)；

（3）当原始序列杂乱无序时，平均时间复杂度为O(n^2)。

2 空间复杂度：

插入排序过程中，需要一个临时变量temp存储待排序元素，因此空间复杂度为O(1)。

3 算法稳定性：

插入排序是一种稳定的排序算法。