Java学习----数组排序算法

1. 算法概述

• 通常来讲，排序的目的是为了快速查找

• 衡量排序算法的优劣：
   1. 时间复杂度：分析关键字的比较次数 和 记录的移动次数
   2. 空间复杂度：分析排序算法中需要多少辅助内存
   3. 稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

• 排序算法分类：内部排序和外部排序。
   内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
   外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

• 十大内部排序算法：

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

2. 算法特征

算法的5大特征：

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

3. 冒泡排序

排序思想：

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

public static void main(String[] args) {
	  int[] arr = new int[]{0,1,8,7,-62,45,-11,35,-48,55,101};
	  
	  //遍历排序前的数组
	  for (int a : arr){
	      System.out.print(a +"\t");
	  }
	  System.out.println();
	  // 外层控制比较次数  n 个元素  比较 n-1
	  // 内存循环来控在每次比较时的相邻元素的比较和交换
	  for (int i = arr.length -1 ;i >= 0;i--){ //比较的次数是递减的
	      for (int j = 0;j < i;j++){ //控制要比较的元素 元素的个数是随着比较的次数变换的
	          //比较相邻的两个元素
	          if (arr[j] > arr[j+1]){ //如果左边的大于右边 则需要交换两个元素的位置
	              int temp = arr[j];
	              arr[j] = arr[j+1];
	              arr[j+1] = temp;
	          }
	      }
	  }
	  // 遍历数组
	  for (int a : arr){
	      System.out.print(a +"\t");
	  }
}

结果截图：

4. 快速排序

排序思想：

1. 从数列中挑出一个元素，称为"基准"（pivot），
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后， 该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
4. 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代 （iteration）中，它至少会把一个元素摆到它最后的位置去。

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[]{0,1,8,7,-62,45,54,-11,35,-48,55,101};

        quickSort(arr);
        printArr(arr);
    }

    // 快速排序
    public static void quickSort(int[] arr) {
        if (arr.length <= 1){
            return;
        }
        sort(arr,0,arr.length - 1); //这是第一次
    }

    // 核心算法
    public static void sort(int[] arr,int left,int right){
        if (left > right){ //对于传入的参数要判断 不能交叉越界
            return;
        }
        int base = arr[left]; //基准元素
        int l = left, r = right;
        while (l != r){
            //从右往左找
            while (arr[r] >= base && l < r){ //从右往左 while结束 就是找见比基准小的元素
                r--;
            }
            //从左往右找
            while (arr[l] <= base && l < r){ //找到比基准打的数
                l++;
            }
            if (l < r){
                int temp = arr[l];
                arr[l] = arr[r];
                arr[r] = temp;
            }
        }
        // base归回 回到中间位置 此时位于base左边的都是比他小的 位于base右边都是比他大的
        arr[left] = arr[l];
        arr[l] = base;
        sort(arr,left,l - 1);//对左半边进行递归排序
        sort(arr,r + 1,right); //对右半边
    }

    public static void printArr(int[] arr){
        for (int a : arr){
            System.out.print(a +"\t\t");
        }
    }
}

5. 选择排序

• 工作原理为：在未排序的序列中找出最小(大)元素与第一个位置的元素交换位置
• 选择排序与冒泡排序的区别：
   冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；
   选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。然后在剩下的元素中再找最小(大)元素与第二个元素的位置交换，依此类推，直到所有元素排序排序完成。
• 算法简介：
  1.初始状态：序列为无序状态。
  2.第1次排序：从n个元素中找出最小(大)元素与第1个记录交换
  3.第2次排序：从n-1个元素中找出最小(大)元素与第2个记录交换
  4.第i次排序：从n-i+1个元素中找出最小(大)元素与第i个记录交换
  5.以此类推直到排序完成

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = new int[]{0,1,8,7,-62,45,54,-11,35,-48,55,101};
        System.out.println("排序前的数组：");
        printArr(arr);
        selectSort(arr);
        System.out.println("最终结果：");
        printArr(arr);
    }

    public static void selectSort(int[] arr) {
        for (int i = 0;i < arr.length;i++) { //控制比较的次数
            int minIndex = i; //minIndex表示 记录最小元素所在的位置  假设每次开始的位置为最小元素
            for (int j = i; j < arr.length - 1; j++) { //控制元素之间的比较
                if (arr[minIndex] > arr[j]) {
                    minIndex = j;
                }
            }
            swap(arr,i,minIndex);
            System.out.println("第"+ i +"次比较：");
            printArr(arr);
        }
    }

    //交换数组中两个元素的位置
    private static void swap(int[] arr,int index1,int index2) {
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }

    public static void printArr(int[] arr){
        for (int a : arr){
            System.out.print(a +"\t");
        }
        System.out.println();
    }
}

6. 插入排序

• 算法简介：
  1.从第一个元素开始，该元素可认为已排序。
  2.取出下一个元素，在排序好的元素序列中从后往前扫描
  3.如果元素(已排序)大于新元素，将该元素移到下一位置
  4.重复3.直到找到已排序的元素小于或等于新元素的位置
  5.将新元素插入该位置后
  6.重复2-5直到排序完成

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = new int[]{0,1,8,7,-62,45,54,-11,35,-48,55,101};
        insertSort(arr);
    }

    private static void insertSort(int[] arr) {
        for (int i = 0;i < arr.length - 1;i++){
            for (int j = i + 1;j > 0;j--){
                if (arr[j] < arr[j - 1]){
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j-1] = temp;
                }else{ //当后边的元素比前边的元素大或者相等的时候不用交换  直接结束循环
                    break;
                }
            }
        }
        for (int a : arr){
            System.out.print(a +"\t");
        }
    }
}

7. 排序算法的选择

• (1)若n较小(如n ≤ 50)，可采用直接插入或直接选择排序。 当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。

• (2)若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；

• (3)若n较大，则应采用时间复杂度为O(nlog₂n)的排序方法：快速排序、堆排序或 归并排序。