java11----数组排序

java11----数组排序

数组排序：把数组中得元素，通过比较移位替换，使之变成一个有序序列

排序方式：冒泡排序，选择排序，插入排序，希尔排序，快速排序，基数排序，堆排序，归并排序。

• 冒泡排序

冒泡排序：数组元素 两两比较，大的往后放，经过一轮比较后，最大得元素会出现在最后面，如此往复，那么整个数组元素就有序了。
代码演示：
 int[] arr = {24, 69, 80, 57, 13, 20, -1, 0};
        //  tuiDao(arr);
        //外层循环控制轮次
        for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    //交换位置
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

• 选择排序

选择排序：每次拿一个元素和后面所有得元素挨个比较，小得往前放，经过一轮比交换，最小得元素会出现在最前面，如此往复，整个数组就排好序了。
代码演示：
int[] arr = {24, 69, 80, 57, 13,20,50,200,0,-1};
        //快速把一坨代码，抽到方法中 ctrl+alt+M
      //  tuiDao(arr);
        for (int index = 0; index < arr.length-1; index++) {
            for (int i = 1 + index; i < arr.length; i++) {
                if (arr[index] > arr[i]) {
                    //交换位置
                    int t = arr[index];
                    arr[index] = arr[i];
                    arr[i] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

• 插入排序

插入排序：每次将后面一个元素，插入到之前得一个有序序列中，使之仍保持有序
代码演示：
int[] arr = {9, 1, 0, 4, 3, 5, 7, 6, 8, 11, 10, 13, 12,-1,-1,100};
        //[1,0,9]
        //直接插入排序
        //外层循环定义轮次
        for (int i = 1; i < arr.length; i++) {
            //比较大小交换位置
            int j=i;
            while (j>0&&arr[j]<arr[j-1]){
                int t=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=t;
                j--;
            }
        }

        System.out.println(Arrays.toString(arr));

    }
}

• 二分查找

查找思想：前提条件：数组元素必须有序，二分查找：每次查找一半。
代码演示：
public class MyTest2 {
    public static void main(String[] args) {
        //查找思想：前提条件：数组元素必须有序，二分查找：每次查找一半
        int[] arr = {10, 20, 30, 50, 90, 100, 101, 300, 400};
        int index = getIndex(arr, 90);
        System.out.println("索引是" + index);
    }

    //二分查找
    private static int getIndex(int[] arr, int ele) {
        //定义三个索引
        int minIndex = 0;
        int maxIndex = arr.length - 1;
        int centerIndex = (minIndex + maxIndex) / 2;
        while (minIndex <= maxIndex) {
            if (ele == arr[centerIndex]) {
                return centerIndex;
            } else if (ele > arr[centerIndex]) {
                minIndex = centerIndex + 1;
            } else if (ele < arr[centerIndex]) {
                maxIndex = centerIndex - 1;
            }
            //重新计算中间索引
            centerIndex = (minIndex + maxIndex) / 2;
        }
        return -1;
    }
}

• 快速排序

快速排序：是一种速度快，效率高的排序算法。
快排原理：
        在要排的数（比如数组A）中选择一个中心值key（比如A[0]），通过一趟排序将数组A分成两部分，其中以key为中心，key右边都比key大，key左边的都key小，然后对这两部分分别重复这个过程，直到整个有序。
        整个快排的过程就简化为了一趟排序的过程，然后递归调用就行了。
        一趟排序的方法：
1，定义i=0，j=A.lenght-1，i为第一个数的下标，j为最后一个数下标
2，从数组的最后一个数Aj从右往左找，找到第一小于key的数，记为Aj；
3，从数组的第一个数Ai 从左往右找，找到第一个大于key的数，记为Ai；
4，交换Ai 和Aj 
5，重复这个过程，直到 i=j
6，调整key的位置，把A[i] 和key交换
假设要排的数组为：A[8] ={ 5 2 8 9 2 3 4 9 }
           选择 key = 5， 开始时 i=0，j=7
  index       0    1    2    3    4    5    6    7

开始：       5    2    8    9    2    3    4    9
                  i                                         j  
第一次找   5    2    8    9    2    3    4    9
                              i                       j
交换：       5    2    4    9    2    3    8    9 
                              i                       j
第二次找   5    2    4    9    2    3    8    9
                                    i           j
交换：       5    2    4    3    2    9    8    9
                                    i            j
第三次找    5    2    4    3    2    9    8    9
                                          ij   
调整key： 2    5    4    3    5    9    8    9
                                           ij

代码演示：
package com.quicksort;
 
import java.util.Arrays;
 
public class QuickSort {
	public static void main(String[] args) {
		int[] a = {1, 2, 4, 5, 7, 4, 5 ,3 ,9 ,0};
		System.out.println(Arrays.toString(a));
		quickSort(a);
		System.out.println(Arrays.toString(a));
	}
 
	public static void quickSort(int[] a) {
		if(a.length>0) {
			quickSort(a, 0 , a.length-1);
		}
	}
 
	private static void quickSort(int[] a, int low, int high) {
		//1,找到递归算法的出口
		if( low > high) {
			return;
		}
		//2, 存
		int i = low;
		int j = high;
		//3,key
		int key = a[ low ];
		//4，完成一趟排序
		while( i< j) {
			//4.1 ，从右往左找到第一个小于key的数
			while(i<j && a[j] > key){
				j--;
			}
			// 4.2 从左往右找到第一个大于key的数
			while( i<j && a[i] <= key) {
				i++;
			}
			//4.3 交换
			if(i<j) {
				int p = a[i];
				a[i] = a[j];
				a[j] = p;
			}
		}
		// 4.4，调整key的位置
		int p = a[i];
		a[i] = a[low];
		a[low] = p;
		//5, 对key左边的数快排
		quickSort(a, low, i-1 );
		//6, 对key右边的数快排
		quickSort(a, i+1, high);
	}
}