简单排序算法

冒泡排序

两个for循环，两两进行比较，如果满足规则，则将两个数据进行交换

    public int[] maopao() {
        int[] arrays = {1, 3, 9, 5, 11, 66, 85, 97, 101, 588, 469, 258, 147, 369, 456};

        for (int i = arrays.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arrays[j] > arrays[j + 1]) {
                    int temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                }
            }
        }
        return arrays;
    }

优化1

    public int[] maopao1() {
        int[] arrays = {1, 3, 9, 5, 11, 66, 85, 97, 101, 588, 469, 258, 147, 369, 456};

        for (int i = arrays.length - 1; i > 0; i--) {

            //是否发生了交换
            boolean isExchanged = false;
            for (int j = 0; j < i; j++) {
                if (arrays[j] > arrays[j + 1]) {
                    int temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                    //发生了交换
                    isExchanged = true;
                }
            }

            //如果没有发生交换 表示已经是有序状态 没有必要继续遍历了
            if (!isExchanged) {
                break;
            }
        }

        return arrays;
    }

优化二

    public int[] maopao2() {
        int[] arrays = {1, 3, 56, 32, 33, 5, 6, 60, 61, 62, 63, 64};

        for (int i = arrays.length - 1; i > 0; i--) {

            //记录最后一次发生交换的坐标位置，该坐标之后的数据没有发生交换，代表是有序状态
            int changeIndex = 0;
            for (int j = 0; j < i; j++) {
                if (arrays[j] > arrays[j + 1]) {
                    int temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                    //最后一次发生交换的坐标
                    changeIndex = j + 1;
                }
            }

            //下次可以从发生交换坐标的位置开始循环
            i = changeIndex;
        }

        return arrays;
    }

选择排序

不断的从数组中找出最大值，然后放入末尾

    public int[] xuanze() {
        int[] arrays = {1, 3, 9, 5, 11, 66, 85, 97, 101, 588, 469, 258, 147, 369, 456};

        for (int i = arrays.length - 1; i > 0; i--) {
            
            //记录下标
            int maxIndex = 0;
            for (int j = 0; j < i; j++) {
                if (arrays[maxIndex] < arrays[j + 1]) {
                    //记录较大值的下标，循环进行比对，找到最大值下标
                    maxIndex = j + 1;
                }
            }

            //将最大值与队尾进行交换 然后进行下一次遍历
            int temp = arrays[maxIndex];
            arrays[maxIndex] = arrays[i];
            arrays[i] = temp;

        }

        return arrays;
    }

插入排序

从数组中获取数字，并和已有的数据进行对比，选择自己插入的位置

    public int[] charu() {
        int[] arrays = {1, 3, 9, 5, 11, 66, 85, 97, 101, 588, 469, 258, 147, 369, 456};


        int current = 0;
        for (int i = 1; i < arrays.length - 1; i++) {
            //取出比较项
            current = arrays[i];
            //记录比较项前一项的下标
            int pre = i -1;
            //当前比较项数据小于前一项数据
            while (pre >= 0 && current < arrays[pre]) {
                //将前一项数据赋值给当前数据
                arrays[pre + 1] = arrays[pre];
                //下标前移 将比较项与更前边的数据进行比较
                pre--;
            }
            //当移到最前边 或者是比较项数据大于前一项数据的时候 将比较项赋值给前一项数据后边的位置
            arrays[pre + 1] =current;
        }

        return arrays;
    }

希尔排序

将序列分成一个矩阵，分为m列，逐列进行排序，m从某个整数逐渐减为1，当m为1的时候，整个序列将完全有序
希尔排序是插入排序的改进版本，是一个非稳定排序。

希尔排序介绍

快速排序

快速排序的本质就是把基准数大的都放在基准数的右边,把比基准数小的放在基准数的左边,这样就找到了该数据在数组中的正确位置.
再采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。

void Quick_Sort(int *arr, int begin, int end){
    if(begin > end)
        return;
    int tmp = arr[begin];
    int i = begin;
    int j = end;
    while(i != j){
        while(arr[j] >= tmp && j > i)
            j--;
        while(arr[i] <= tmp && j > i)
            i++;
        if(j > i){
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    }
    arr[begin] = arr[i];
    arr[i] = tmp;
    Quick_Sort(arr, begin, i-1);
    Quick_Sort(arr, i+1, end);
}

二分法查找

二分法查找的思路如下：

（1）首先，从数组的中间元素开始搜索，如果该元素正好是目标元素，则搜索过程结束，否则执行下一步。

（2）如果目标元素大于/小于中间元素，则在数组大于/小于中间元素的那一半区域查找，然后重复步骤（1）的操作。

（3）如果某一步数组为空，则表示找不到目标元素。

    public int binarySearch(int[] arr, int key) {
        int left = 0; //数组最小索引值
        int right = arr.length - 1; //数组最大索引值
        while (left < right) {
            int mid = (left + right) / 2;//获得中间值，将数组一分为二
            if (key == arr[mid]) {
                return mid + 1;
            } else if (key > arr[mid]) {//key大于中间值，因此在右侧的二分之一数组中再次寻找
                left = mid + 1;
            } else {//同理
                right = mid - 1;
            }
        }
        return -1;//没有找到
    }