简简单单聊算法

浅谈冒泡，快速排序

前言：
　　算法一直是程序员比较头疼的业务之一，那么如何可以以通俗易懂的方式来聊一聊它们呢，那么排序就可以很好的从侧面来展现算法的意义

　　算法不仅仅是要达到解决问题的目标，我们更应该去想如何优化算法，考虑它们的 重点：时间复杂度（运行所需要的计算工作量，简单来说就是计算的次数）和空间复杂度（运行所需要的内存），然后还要保证健壮性（总不可能写了个算法，运行时出现崩溃的情况吧。嘻嘻）

　　我们先从冒泡排序开始了解，给定一个数组，例如[1,4,2,9,6,4,5,7,3,8]，需要我们按从小到大的方式去排序我们首先能想到的大概都是一个一个去比较，当当前数字大于后一个数字时，就交换位置

　　话不多说 上代码分析

 

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[]{1,4,2,9,6,4,5,7,3,8};
        System.out.println(Arrays.toString(arr));
　　　　　　//调用函数
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void bubbleSort(int[] arr){
        //外层循环
        for (int i = 0; i < arr.length-1; i++) {

            for (int j = 0; j < arr.length-i-1; j++) {
            //for (int j = 0; j < arr.length-1; j++)
                /*
                * 如果当前数字小于下一个数字 ，就交换它们的位置，然后接着比下去，直到比到最后一个，那么最后一个已经是最大的了
                * 当这层循环结束以后，跳到外层循环
                * */
                if(arr[j]>arr[j+1]){
                    int tem = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1]=tem;
                }

            }

        }
    }
}
当然这种算法的时间复杂度随着数组长度的大小，影响是较大的O(N^2)，但是我们依旧可以去想方法能优化一点算一点，内层的两个for循环，虽然在实际运行中体现的差异不大，甚至可以说感受不出来，但是还是减少了计算的次数。

 快速排序：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[]{1,5,3,8,7,5,4,9,4,6,1,6,0};
　　　　　　//调用函数
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));

    }

    public static void quickSort(int[] arr,int start,int end){
        if(start<end){
            //选定标准数
            int stard = arr[start];
            //记录高，低位的下标
            int low=start;
            int high = end;
            //循环找比标准数大的数和比标准数小的数
            while (low<high){
                while (low<high&&stard<arr[high]){
                    high--;
                }
                //使用高位的数字替换低位的数字
                arr[low]=arr[high];
                while (low<high&&arr[low]<=stard){
                    low++;
                }

　　　　　　　　　　//使用低位的数字替换高位的数字

               arr[high]=arr[low];

            }
            arr[low]=stard;
　　　　　　　　//递归思想，调用此方法
            quickSort(arr,start,low-1);
            quickSort(arr,low+1,end);

        }

    }
}
在此算法中需要去理解的是high 位和 low 位 和标准数比较的流程，当高位小于等于标准数，把值赋给低位;当低位大于标准数，把值赋给高位；不断执行下去，直到low不小于high,外层继续调用此方法，直到start不小于end,整个程序结束。
总结就是不断去和标准数比较，完成高位和低位数值的交换，递归思想，不断比较，直到start不小于end,结束。