各种基础的算法，比如冒泡排序、选择排序。贪心算法等。。。

一、快速排序

原理：每次从待排序数据中找出最小（最大）的元素，将其放到序列的起始位置，然后对剩余未排序的元素执行相同的操作，直到全部元素排序完成。
流程：只会拿一个数据，不会像冒泡排序一样，不断比较相邻两个元素的大小，且不断交换位置。
复杂度：时间复杂度：O(n^2)空间：O(n)。   n会随着数组大小而发生平方级别的增长。
代码如下(默认采用JAVA)：

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        selectionSort(arr); // 调用 排序算法
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) { // 循环n-1躺
            int minIndex = i; // 每次循环 默认最值下标为首元素下标
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j; // 记录每一躺最值的下标
                }
            }
            if (minIndex != i) { // 交换最值对应下标的元素值
                int temp = arr[minIndex];
                arr[minIndex] = arr[i];
                arr[i] = temp;
            }
        }
    }
}

二、快速排序

原理：快速排序是一种高效的排序算法，一趟排序将待排记录分割为独立的两部分，其中一部分的元素值 均 比另一部分元素值小，分别对这两部分元素进行排序，以达到整个序列有序的目的。 整个过程采用递归的方式。借鉴了分而治之的思想：每次将数列分为两部分。

时间复杂度：O(nlogn)   空间复杂度：O(logn)。

 问题1：独立的两部分，是怎么判断的？ 采用“基准”，来判断，基准：基准的左边小于基准，基准的右边都大于基准。

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {3, 8, 2, 5, 1, 4, 7, 6};
        quickSort(arr, 0, arr.length - 1); // 将整个数组，首元素，尾元素一并放入quickSort中
        for (int i : arr) { // foreach循环 输入 排序后的结果
            System.out.print(i + " ");
        }
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high); // 找到分割点的位置，大小不一致
            quickSort(arr, low, pivotIndex - 1); 
            quickSort(arr, pivotIndex + 1, high);
        }
    }

    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[low]; // “基准值”
        while (low < high) {
            while (low < high && arr[high] >= pivot) { //比 “基准”大的元素放到左边
                high--;
            }
            arr[low] = arr[high];
            while (low < high && arr[low] <= pivot) { // 比“基准”小的元素放到右边
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = pivot; // 返回 “基准值”
        return low;
    }
}

   三、冒泡排序

原理：如同名字一般，冒泡的方式选择最大（最小）数。

流程：每一躺（次）循环，都会产生一个最大（最小）的数，沉入数组的底部[末尾]。如果存在M个数，则产生M-1躺排序。

复杂度：时间复杂度：O(n^2)空间：O(1)。 n会随着数组大小而发生平方级别的增长。

代码如下(默认采用JAVA)：

import java.util.Arrays;

public class Day1_MaopaoSort {
    public static void myBubblesort(int[]array){
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array.length-1;j++){
                if(array[j]>array[j+1]){
                    int tmp=0;
                    tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                }}}}
    public static void main(String[] args) {
        int[] array = {10, 52, 3, 7, 6};
        myBubblesort(array);
        System.out.println(Arrays.toString(array));
    }
}