算法笔记-排序算法(冒泡 选择 插入)

首先罗列一下常见的十大排序算法：

 

一.冒泡排序

1. 定义:

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐逐渐向上冒。    

 

                                              

2. 图是过程:

 

3.java代码实现:

package com.nmys.story.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

/**
 * @Auther: Jia
 * @Date: 2019/8/20 22:14
 * @Description:冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        //int arr[] = {3, 9, -1, 10, 20};
        //bubbleSort(arr);
        //System.out.println("排序后");
        //System.out.println(Arrays.toString(arr));

        int[] arr =  new int[80000];
        for (int i = 0; i <80000 ; i++) {
           arr[i] = (int) (Math.random()*8000000);
        }
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是=" + date1Str);

        //测试冒泡排序
        bubbleSort(arr);

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间是=" + date2Str);
    }

    public static void bubbleSort(int[] arr){
        int temp = 0;
        boolean flag = false;
        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]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = true;
                }
            }
                //System.out.println("第" + (i + 1) + "趟排序后的数组");
               // System.out.println(Arrays.toString(arr));
                // 在一趟排序中，一次交换都没有发生过
                if(!flag){
                   break;
                }else {
                    // 重置flag!!!, 进行下次判断
                    flag = true;
                }
        }
    }


}

4. 复杂度:

• 时间复杂度：O(n²)
• 空间复杂度：O(1)，只需要一个附加程序单元用于交换
• 稳定性：不稳定 冒泡排序是不稳定的排序算法，最好情况下（初始数组本来就有序），算法执行一趟冒泡即可，做 n-1 次比较，0次交换即可，最坏情况下（初始数组完全逆序），算法需要执行 n-1 趟冒泡，比较总次数为 n * (n-1) / 2，交换总次数为 n * (n-1) / 2

5. 优化：

因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志 flag 判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化，可以在冒泡排序写好后，在进行)

 

二. 选择排序

1. 定义:

选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。

 

2. 图解过程:

 

3. java代码实现:

/**
     * 选择排序
     *
     * 1. 从待排序序列中，第一个元素假如最小和后面元素比较
     * 2. 如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；
     * 3. 从余下的 N - 1 个元素中，找出第二小的元素，重复①、②步，直到排序结束。
     * 
     * @param arr  待排序数组
     */
    public static void selecionSort(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
            int k = i;
            for (int j =i+1; j <arr.length ; j++) {
                if(arr[k]>arr[j]){
                    k=j;//找出最小值的下标
                }
            }
            // 将最小值放到未排序记录的第一个位置
            if(k>i){
                int tmp =arr[i];
                arr[i]=arr[k];
                arr[k]=tmp;
            }
        }

    }

 

4. 复杂度:

平均时间复杂度	最好情况	最坏情况	空间复杂度
O(n²)	O(n²)	O(n²)	O(1)

选择排序的简单和直观名副其实，这也造就了它”出了名的慢性子”，无论是哪种情况，哪怕原数组已排序完成，它也将花费将近n²/2次遍历来确认一遍。即便是这样，它的排序结果也还是不稳定的。 唯一值得高兴的是，它并不耗费额外的内存空间。

 

三. 插入排序

1. 定义:

插入排序的设计初衷是往有序的数组中快速插入一个新的元素。它的算法思想是：把要排序的数组分为了两个部分, 一部分是数组的全部元素(除去待插入的元素), 另一部分是待插入的元素; 先将第一部分排序完成, 然后再插入这个元素. 其中第一部分的排序也是通过再次拆分为两部分来进行的.

插入排序由于操作不尽相同, 可分为 直接插入排序 , 折半插入排序(又称二分插入排序), 链表插入排序 , 希尔排序 。我们先来看下直接插入排序。

直接插入排序的基本思想是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过为止。

2. 图解过程:

 

3. 代码实现:

/**
     * 插入排序
     *
     * 1 从第一个元素开始，该元素可以认为已经被排序
     * 2 取出下一个元素，在已经排序的元素序列中从后向前扫描
     * 3 如果该元素（已排序）大于新元素，将该元素移到下一位置
     * 4 重复步骤3，
     * 5 将新元素插入到该位置后
     * 6\. 重复步骤2~5
     * @param arr  待排序数组
     */
    // 插入排序，a 表示数组，n 表示数组大小
    public static void insertionSort(int[] a,int n){
        if(n<=1) return;
        for (int i = 1; i <n ; i++) {
            int temp = a[i];//相当临时变量暂存
            int k=i-1;//相当于指针来回移动
            for ( ;k >=0 ; --k) {
                if(a[k]>temp){
                    a[k+1]=a[k];//数据移动
                }else{
                    break;
                }
            }
            a[k+1] =temp;//插入数据
        }

    }

4. 复杂度:

平均时间复杂度	最好情况	最坏情况	空间复杂度
O(n²)	O(n)	O(n²)	O(1)

Tips: 由于直接插入排序每次只移动一个元素的位， 并不会改变值相同的元素之间的排序， 因此它是一种稳定排序。