Java五个常见排序算法

冒泡排序（最好理解）

基本思想： 依次比较 利用两次循环 把大的数值往一边移动。

 public static void Maopao(int arr[]){

        //用作交换变量
        int temple=0;
        //用于提前结束排序
        boolean flag=false;
        for (int i=0;i<arr.length-1;i++){
            //第一层控制轮数
            for (int j=0;j<arr.length-1-i;j++){
                //第二次依次把最大值往后移
                if(arr[j]>arr[j+1]){
                    flag=true;
                    temple=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temple;
                }
            }
            //判断 如果没有移动 表明已经排好 可以提前退出
            if(flag){
                flag=false;
            }else{
                break;
            }
        }
    }

快速排序（最快的排序法）

基本思想： 找出数组中间值 比他大的移到左边 比他小的移到右边

public static void sort(int[] arr,int left,int right){
        int l=left;
        int r=right;
        int flag=arr[l];
        int temple;
        while (l<r){
            while (arr[l]<=flag && l<right){//    找出左边 比flag大的 确保不超出坐标范围
                l++;
            }

            while (arr[r]>flag && r>left){//找出右边比falg 小的   确保不超出坐标范围
                r--;
            }

            if (l<r){ // 没碰头  进行转换
                temple=arr[l];
                arr[l]=arr[r];
                arr[r]=temple;
            }
        }

        //最后和r对应的交换

        temple=arr[r];
        arr[r]=arr[left];
        arr[left]=temple;

        // 防止 栈溢出  判断传进去的  是不是满足要求
        if (left<r-1){
            sort(arr,left,r-1);
        }
        if (r+1<right){
            sort(arr,r+1,right);
        }



    }

选择排序

基本思想：从数组中选择最小值 然后排在前面
第一次从arr[0]_{arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]}arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]_{arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]}arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

 public static void selectSourt(int[] arr){

        for (int i = 0; i < arr.length-1; i++) {
            int min=arr[i];//记录最小值
            int mindex=i;//记录最小值对应的坐标

            for (int j = i+1; j < arr.length; j++) {
                if (min>arr[j]){
                    //找出 剩下的最小值及其坐标
                    min=arr[j];
                    mindex=j;
                }
            }

            //将最小值移到前面
            arr[mindex]=arr[i];
            arr[i]=min;

        }
    }

插入排序

基本思想：
把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

public static void charuSourt(int[] arr){
        int index=0;//记录坐标
        int value=0;//记录当前操作的值
        //循环目的：控制次数个起始值
        for (int i=1;i<arr.length;i++){
            index=i-1;//坐标向前移动 进行比较
            value=arr[i];
            //循环目的：找出该插入的位置坐标
            while (index>=0 && value<arr[index]){
                arr[index+1]=arr[index];
                index--;
            }
            arr[index+1]=value;

        }

    }

希尔排序(插入排序的优化)

基本思想：
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

public static void xier(int [] arr){
        int temple=0;
        //循环：逐步切分步长 步长为一是就是插入排序了
        for (int grap=arr.length/2;grap>=1;grap=grap/2){
            //循环目的：控制次数
            for (int i=grap;i<arr.length;i++){
                //利用i-grap 找出对应的值比较 交换顺序
                for (int j=i-grap;j>=0;j=j-grap){
                        if (arr[j]>arr[i]){
                            temple=arr[j];
                            arr[j]=arr[i];
                            arr[i]=temple;
                        }
                }
            }
        }
    }