java实现常用排序算法

排序算法

内部排序

   整个排序过程不需要借助外部存储器，所有排序操作都在内存中完成。

外部排序

   参与排序的数据非常多，整个计算过程无法全部在计算机内存中完成，必须借助外部存储器。外部排序最常见的排序是多路归并排序，可以认为外部排序是由多次内部排序完成。

十大内部排序

    选择排序：直接选择排序、堆排序
    交换排序：冒泡排序、快速排序
    插入排序：直接插入排序、折半插入排序、Shell排序
    不常用排序：归并排序、桶式排序、基数排序

算法的5大特征

    输入：有0个或多个输入数据，这些输入必须有清楚的描述和定义
    输出：至少有一个或者多个输出结果，不可以没有输出结果
    有穷性：算法在有限的步骤之后会自动结束而不会无限循环，每一个步骤可以在可接受的时间内完成
    确定性：算法中的每一步都有明确的含义，不会出现二义性
    可行性：算法的每一步都是清楚且可行的，能让用户用纸笔计算而求出答案。

冒泡排序

  思路： 两两比较相邻记录的关键字，如果反序则进行交换，知道没有反序的记录为止。

         //冒泡排序（由小到大排序）将相邻两个数字进行比较，依次进行排序
        int [] arr = new int[]{88,78,35,789,185,65};
        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;
                }
            }
        }

优化冒泡排序代码
  通过对冒泡排序的测试我们发现在某些极端的情况下，经过少量的交换调整整个数组已经达到了有序的排列，此时不需要在进行后续的排序调整，所以在代码中加入一个标志，通过标志得出当前数组是否已经有序，如果有序的话直接跳出后续的判断过程。

boolean flag = false;
        for (int i = 0 ; i < nums.length -1 ; i++){
            for (int j = 0 ; j < nums.length - 1 - i ; j ++){
                if (nums[j] > nums[j+1]){
                    flag = true;
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
            System.out.println("第" + (i +1) + "次交换");
            if (!flag){
                break;
            }else {
                flag = false;
            }
        }

选择排序

  思路： 通过 n - i 次关键字的比较，从 n - i + 1 个数据中选出最小的一个数据，将这个数据和第 i 个数据进行交换。

public void selectSort(int[] arr){
        for (int i = 0 ; i < arr.length ; i++){
            int min = i;
            for (int j = i + 1 ; j < arr.length  ; j++){
                if (arr[j] < arr[min]){
                    min = j;
                }
            }
            if (i != min){
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }
    }

插入排序

  思路： 将一个数据插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。

public void insertSort(int[] arr){
        int value = 0;
        int index = 0;
        for (int i = 1 ; i < arr.length ; i++){
             value = arr[i];
             index = i - 1;
            while (index >= 0 && value < arr[index]){
                arr[index + 1] = arr[index];
                index--;
            }
            arr[index + 1] = value;
        }
    }

希尔排序

  思路： 将原本的大量数据分割成若干个子序列，然后在这些子序列内部分别进行直接插入排序，当整个序列都基本有序时，再对全体记录进行一次直接插入排序。

/*
      *@Description: 采用交换法实现希尔排序
      *@Param:
      *@return:
      *@Author: 张帅
      *@Date: 2021/10/15 17:23
     **/

    public void shellSortSwap(int[] arr) {
        int temp = 0;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
    }

    /*
      *@Description: 采用位移法来实现希尔排序
      *@Param: 
      *@return:  
      *@Author: 张帅
      *@Date: 2021/10/15 17:47
     **/
    
    public void shellSort(int[] arr) {
        int temp = 0;//用来存放要插入的数据
        int index = 0;//用来存放要比较的元素的下标
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                temp = arr[i];
                index = i;
                while ((index -= gap) >= 0 && temp < arr[index]) {
                    arr[index + gap] = arr[index];
                }
                arr[index + gap] = temp;
            }
        }
    }

快速排序

  思路： 通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

public class QuickSort {
    public void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int l = left;
            int r = right;
            int temp = arr[l];
            while (l < r) {
                while (l < r && arr[r] > temp) {
                    r--;
                }
                if (l < r) {
                    arr[l++] = arr[r];
                }
                while (l < r && arr[l] < temp) {
                    l++;
                }
                if (r > l) {
                    arr[r--] = arr[l];
                }
                arr[l] = temp;
                quickSort(arr, left, r - 1);
                quickSort(arr, l + 1, right);
            }
        }
    }
}

算法性能对比

O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)