排序算法 |冒泡排序、选择排序、插入排序，快速排序

1. 冒泡排序

冒泡排序原理:
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

package homeworkC;
import java.util.Arrays;


public class BubbleSort {
    public static void main(String[] args) {
        //冒泡排序法
        int[] arr={6,80,-3,4,85,52,79,4,-6,2,9,8};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));

    }

    private static void bubbleSort(int[] arr) {
        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;
                }
            }
        }
    }
}

2. 选择排序

选择排序原理:
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

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

3. 插入排序

直接插入排序的原理：
将一个数插入到一个长度为m的有序表中,使之仍保持有序,从而得到一个新的长度为m+1的有序列表.

public class test2 {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 5, 7, 8, 9, 3, 4, 52, 1, 3};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void insertSort(int[] arr) {
        //从i=1 开始，因为单独一个元素arr[0]是有序的；
        for (int i = 1; i < arr.length; i++) {
            //从无序数列中取出一个元素赋值给temp
            int temp = arr[i];
            int t = i - 1;
            //不断往前寻找，直到找到比temp小的值或者t小于0为止
            while (t >= 0 && arr[t] > temp) {
                arr[t + 1] = arr[t];
                t--;
            }
            //将temp插在其之后
            arr[t + 1] = temp;

        }
    }
}

4. 快速排序

快速排序的原理：
a.从数组中取出一个数，作为基准数。
b.分区：将比这个数大或等于的数全放到他的右边，小于他的数全放到他的左边。
c.再对左右区间重复第二步，直到各区间只有一个数。

package homeworkC;
import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        //快速排序
        int[] arr={6,80,-3,4,7};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    private static void quickSort(int[] arr,int start,int end) {
        if(start<end) {//循环终止条件
            int index = quickSortIndex(arr, start, end);
            quickSort(arr, start, index - 1);
            quickSort(arr, index + 1, end);
        }
    }

    private static int quickSortIndex(int[] arr, int st, int en) {
        int x=arr[st];
        int i=st;
        int j=en;
        while (i<j) {//判断终止条件 ,这里是if，不是while！所以只有一次“循环"
            if (i < j && arr[j] >= x) {
                j--;
            }
            if (i < j && arr[j] < x) {
                arr[i] = arr[j];
                i++;

            }

            if (i < j && arr[i] < x) {
                i++;
            }
            if (i < j && arr[i] >= x) {
                arr[j] = arr[i];
                j--;
            }
        }
        arr[i]=x;
        return i;
    }
}