java常见排序算法

一，性质

1、关于稳定性

不稳定： 快选堆希（快速排序、选择排序、堆排序、希尔排序）

稳 定： 插冒归计基（简单插入排序、冒泡排序、归并排序、计数排序、基数排序）

2、关于时间复杂度

直接插入、直接选择和冒泡排序： O(n2)

​ 快速排序、堆排序和归并排序：O(nlog2n)

​ 基数排序，此外还有桶、箱排序：O(n)

1.冒泡排序

* 相邻元素依次比较，将大的元素放在后面
* 对每一对相邻的元素执行相同的操作，从开始一对到结束一对，最后一个数成为最大的数
* 对所有元素重复以上操作，除了最后一个，直到没有元素进行比较

优点：稳定

缺点：速度较慢，每次只能移动相邻两个元素

package com.test;

public class Bulb {
    public static void main(String[] args) {
        int arr[] = {32,43,12,44};
        bulbSort(arr);
        for (int i : arr) {
            System.out.println(i);
        }
    }

    public static void bulbSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if (arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

2.插入排序

依次将元素插入对应位置，不符合的元素后移

* 从第一元素开始(可看成已经被排序)
* 取出下一个元素，在已排序的元素序列中从后向前扫描
* 如果已排序的元素大于新元素，就将已排序的元素移到下一个位置，重复该步骤
* 直到找到已排序的元素小于或者等于新元素，将新元素插入到该元素位置后
* 重复以上步骤
优点：稳定，速度快

缺点：比较次数不一定，当数据量很大的时候比较的次数越少，插入点后移动的数据越多

package com.test;

public class Insert {
    public static void main(String[] args) {
        int arr[] = {32,43,12,44};
        InsertSort(arr);
        for (int i : arr) {
            System.out.println(i);
        }
    }

    public static void InsertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            //待插入元素
            int key = arr[i];
            int x;
            for (x = i - 1; x >= 0 && arr[x] > key; x--){
                arr[x+1] = arr[x];
            }
            arr[x+1] = key;
        }
    }
}

3.快速排序

   使用分治法将一个串分为两个子串，左右两个指针相向移动，右指针开始，晓得放左边，大的放右边
* 先找一个基准数，从右往左找比他小的数放在他的左边，从左往右找比他大的数放右边，直到基准数左边全是比他小的，右边全是比他大的
* 然后再在左右两个子串中重复以上步骤，直到排序完成
优点：速度快，数据移动少

缺点：不稳定

package com.test;


public class Quick {
    public static void main(String[] args) {
        int arr[] = {3,43,23,12,55};
        quickSort(arr,1,3);
        for (int i : arr) {
            System.out.println(i);
        }
    }
    public static void quickSort(int[] arr,int left, int right){
        if (left >=right){
            return;
        }else {
//            定义基准值
            int pivot = arr[left];
//            从右开始
            while (left<right){
                while (left < right && arr[right] >= pivot){
                    right--;
                }
               if (left < right){
//                   将右指针指向的元素赋值给左指针指向的元素
                   arr[left] = arr[right];
                   left++;
               }
//               再将左指针右移，直到遇到比基准值大的元素
                while (left<right && arr[left] <= pivot){
                    left++;
                }
//
                if (left<right){
                    arr[right] = arr[left];
                    right--;
                }
            }
            arr[left] = pivot;

            quickSort(arr,left,left -1);
            quickSort(arr,right+1,right);
        }

    }
}

4.选择排序

* 首先在未排序的序列中找到最小(最大)的元素放到排序序列的起始位置
* 再从剩余的排序序列中找最小(最大)的元素放到已排序序列的末尾
* 重复这个步骤直到排序完成

优点：数据移动次数已知为n-1次

缺点：比较次数较多

package com.test;

public class Selection {
    public static void main(String[] args) {

        int arr[] = {3,43,23,12,55};
        selectionSort(arr);
        for (int i : arr) {
            System.out.println(i);
        }
    }

    public  static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int x = i + 1; x < arr.length; x++) {
                if (arr[x] < arr[minIndex]){
                    minIndex = x;
                }
            }

            if (i != minIndex){
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }

}

5.归并排序

归并排序就是不断地拆分，直到不能拆分再做排序的过程，用到了递归和分治算法。

首先将数据平分成两份，再把两份拆分，直到最后只剩相邻两个元素，不能拆分

再在最小单元中将小的放在前面大的放在后面，排序后将最小单元两两合并，合并时也是按从小到大的顺序排放，不断合并直到复原到最初的大小。

该算法的最优时间复杂度和最差时间复杂度及平均时间复杂度都是一样的为：O( nlogn )

优点：稳定，速度快

缺点：移动数据多，空间复杂度太高

package com.test;

import java.util.Arrays;

public class Merge {
    public static void main(String[] args) {
      int[] arr = {32,43,1,32,55,34,22};
      mergeSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /*
    * arr 原始数组
    * tempArr 临时数组
    * left 当前分组的左边位置序号
    * right 当前分组的右边位置边序号
    *
    * */
    public static void merge(int[] arr, int[] tempArr, int left, int right) {
//       元素大于1 就可以继续划分
        if (left < right) {
//            中间位置
            int mid = (left + right) / 2;
//            左半部分递归划分
            merge(arr, tempArr, left, mid);
//            右半部分递归划分
            merge(arr, tempArr, mid + 1, right);
            int l = left;
            int r = mid + 1;
//            临时数组下标
            int tempIndex = left;
//            循环比较，直到左边后者右边没有元素才停止
            while (l <= mid && r <= right) {
                if (arr[l] < arr[r]) {
                    tempArr[tempIndex++] = arr[l++];
                }else {
                    tempArr[tempIndex++] = arr[r++];
                }
            }
//            左边或者右边还有元素，但两者不可能同时发生
        while (l <= mid){
            tempArr[tempIndex++] = arr[l++];
        }
        while (r <= right){
            tempArr[tempIndex++] = arr[r++];
        }
//        将排序玩完的临时数组中的元素复制到原数组
        while (left <= right){
            arr[left] = tempArr[left];
            left++;
        }

        }else {
            return;
        }
    }

//    开辟临时数组，归并排序
    public static void mergeSort(int[] arr){
        int[] tempArr = new int[arr.length];
        merge(arr,tempArr,0,arr.length-1);
    }
}