排序介绍、冒泡排序和快速排序的实现

排序

• 将一个数据元素的任意序列，重新排列成一个按关键字有序的序列

内部排序和外部排序

• 整个排序过程在内存储器中进行，称为内部排序
• 由于数据量较大，内存储器无法容纳全部数据，需要借助外部存储设备来完成

稳定排序和不稳定排序

• 相同关键字元素的前后关系在排序中发生变化，则排序方法是不稳定的
• 反之稳定
• 无论稳定还是不稳定都能把数据排好序

比较排序和非比较排序

• 大部分排序都是通过比较来排序的

• 有些不需要 计数排序、基数排序

• 四类

  • 插入排序：将无序子序列中的一个或者几个记录插入到有序序列中，从而增加记录的有序子序列的长度
  • 交换排序：通过交换无序序列中的记录从而得到其中关键字最小或最大的记录，并将它加入到有序子序列中，从而增加记录的有序子序列的长度
  • 选择排序：从记录的无序子序列中选择关键字最小或者最大的记录，并将它加入到有序子序列中，从而增加记录的有序子序列的长度
  • 归并排序：通过归并两个或两个以上的记录有序子序列，逐步增加记录有序序列的长度
    

时间复杂度最高的就是三种基本排序：直接排序、简单排序、冒泡排序

冒泡排序

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数
• 针对所有的元素重复以上的步骤，除了最后一个
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

public static void main(String[] args) {
        int[] arr = {2,5,1,3,8,5,7,4,3};
        bubbleSort(arr);
        ArrayUtil.print(arr);
    }
    /**
     * 冒泡排序
     */
    private static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; 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;
                }
            }
        }
    }

快速排序

• 快速排序是冒泡排序的改进版，也是最好的一种内排序，涉及分治和递归。
• 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

private static int partition(int[] arr, int low, int high) {
		//指定左指针i和右指针j
		int i = low;
		int j= high;
		
		//将第一个数作为基准值。挖坑
		int x = arr[low];
		
		//使用循环实现分区操作
		while(i<j){//5  8
			//1.从右向左移动j，找到第一个小于基准值的值 arr[j]
			while(arr[j]>=x && i<j){
				j--;
			}
			//2.将右侧找到小于基准数的值加入到左边的（坑）位置， 左指针想中间移动一个位置i++
			if(i<j){
				arr[i] = arr[j];
				i++;
			}
			//3.从左向右移动i，找到第一个大于等于基准值的值 arr[i]
			while(arr[i]<x && i<j){
				i++;
			}
			//4.将左侧找到的打印等于基准值的值加入到右边的坑中，右指针向中间移动一个位置 j--
			if(i<j){
				arr[j] = arr[i];
				j--;
			}
		}
		
		//使用基准值填坑，这就是基准值的最终位置
		arr[i] = x;//arr[j] = y;
		//返回基准值的位置索引
		return i; //return j;
	}
	private static void quickSort(int[] arr, int low, int high) {//???递归何时结束
		if(low < high){
			//分区操作，将一个数组分成两个分区，返回分区界限索引
			int index = partition(arr,low,high);
			//对左分区进行快排
			quickSort(arr,low,index-1);
			//对右分区进行快排
			quickSort(arr,index+1,high);
		}
	
	}

	public static void quickSort(int[] arr) {
		int low = 0;
		int high = arr.length-1;
		quickSort(arr,low,high);
	}
	
	public static void main(String[] args) {
		//给出无序数组
		int arr[] = {72,6,57,88,60,42,83,73,48,85};

		//输出无序数组
		System.out.println(Arrays.toString(arr));
		//快速排序
		quickSort(arr);
		//partition(arr,0,arr.length-1);
		//输出有序数组
		System.out.println(Arrays.toString(arr));
	}