算法-排序算法

排序算法

选择排序

  public  void selectionSort(int[] arr){
            if(arr == null || arr.length<2){
                return;
            }
            for (int i = 0; i < arr.length-1; i++) {
                int minIndex=i;
                for (int j = i+1; j < arr.length; j++) {
                    minIndex=arr[j]<arr[i]?j:minIndex;
                }
                int temp=arr[i];
                arr[i]=arr[minIndex];
                arr[minIndex]=temp;
            }
        }

冒泡排序

 public static void bubbleSort(int[] arr){
            if(arr == null || arr.length<2){
                return;
            }
            for (int i = arr.length-1; i >0; i--) {
                for (int j = 0; j < i; j++) {
                   if(arr[j]>arr[j+1]){
                    /**
             * 异或运算 相同为0 不同为1
             * 异或：不进位相加
             *  前提a、b 内存不同
             *  a=a^b;
             *  b=a^b; =a^b^b=a^0=a
             *  a=a^b^a=a^a^b=0^b=b
             * 
             */
                       arr[j]=arr[j]^arr[j+1];
                       arr[j+1]=arr[j]^arr[j+1];
                       arr[j]=arr[j]^arr[j+1];
                   }

                }

            }
        }

插入排序

  public  void insertSort(int[] arr) {
            if (arr.length >= 2) {
                for (int i = 1; i < arr.length; i++) {
                    //挖出一个要用来插入的值,同时位置上留下一个可以存新的值的坑
                    int x = arr[i];
                    int j = i - 1;
                    //在前面有一个或连续多个值比x大的时候,一直循环往前面找,将x插入到这串值前面
                    while (j >= 0 && arr[j] > x) {
                        //当arr[j]比x大的时候,将j向后移一位,正好填到坑中
                        arr[j + 1] = arr[j];
                        j--;
                    }
                    //将x插入到最前面
                    arr[j + 1] = x;
                }
            }
        }

快速排序

  public  void QuickSort(int[] arr, int begin, int end) {
            //先定义两个参数接收排序起始值和结束值
            int a = begin;
            int b = end;
            //先判断a是否大于b

            if (a >= b) {
                //没必要排序
                return;
            }
            //基准数,默认设置为第一个值
            int x = arr[a];

            //循环
            while (a < b) {
                //从后往前找,找到一个比基准数x小的值,赋给arr[a]
                //如果a和b的逻辑正确--a<b ,并且最后一个值arr[b]>x,就一直往下找,直到找到后面的值大于x
                while (a < b && arr[b] >= x) {
                    b--;
                }
                //跳出循环,两种情况,一是a和b的逻辑不对了,a>=b,这时候排序结束.二是在后面找到了比x小的值
                if (a < b) {
                    //将这时候找到的arr[b]放到最前面arr[a]
                    arr[a] = arr[b];
                    //排序的起始位置后移一位
                    a++;
                }

                //从前往后找,找到一个比基准数x大的值,放在最后面arr[b]
                while (a < b && arr[a] <= x) {
                    a++;
                }
                if (a < b) {
                    arr[b] = arr[a];
                    //排序的终止位置前移一位
                    b--;
                }
            }
            //跳出循环 a < b的逻辑不成立了,a==b重合了,此时将x赋值回去arr[a]
            arr[a] = x;
            //调用递归函数,再细分再排序
            QuickSort(arr,begin,a-1);
            QuickSort(arr,a+1,end);
        }