O(N^2)的简单排序算法

时间复杂度为：O(N^2)的简单排序算法

注：图来自于网络

选择排序（Select Sort）

选择排序(Selection-sort)是一种简单直观的排序算法。 它的工作原理：首先在未排序序列中找到最小（大）元素，
存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素， 然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕

  /**
     *  选择排序(Selection-sort)是一种简单直观的排序算法。
     *  它的工作原理：首先在未排序序列中找到最小（大）元素，
     *  存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，
     *  然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕
     */
    public  static int[] selectSort(int [] nums){
        if(nums.length<2|| nums==null)return nums;
        //方法一
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = 1 +i; j < nums.length; j++) {
                if(nums[i] > nums[j]){
                  swap(nums,i,j);
                }
            }
        }
        //方法二
//        for (int i = 0; i < nums.length-1; i++) {
//            int minIndex=i;
//            for (int j = i+1; j < nums.length; j++) {
//                minIndex=nums[j]<nums[minIndex]?j:minIndex;
//            }
//            int tmp=nums[i];
//            nums[i]=nums[minIndex];
//            nums[minIndex]=tmp;
//        }
      return nums;
    }

冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，
如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，
也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

  /**
     * 冒泡排序是一种简单的排序算法。
     * 它重复地走访过要排序的数列，一次比较两个元素，
     * 如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，
     * 也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
     * @param nums
     * @return
     */
    public  static int[] bubbleSort(int [] nums){
        if(nums.length<2|| nums==null)return nums;
        //方法一
//        for (int i = nums.length; i >0; i--) {
//            for (int j = 0; j < i; j++) {
//              if(nums[j]>nums[j+1]){
//                  swap(nums,j,j+1);
//              }
//
//            }
//        }
        //方法二
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = 0; j < nums.length-1-i; j++) {
                if (nums[j] > nums[j+1]) {// 相邻元素两两对比
                     swap(nums,j,j+1);
                }
            }

        }
        return nums;
    }

插入算法（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，
找到相应位置并插入。

 /**
     * 插入排序的算法描述是一种简单直观的排序算法。
     * 它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，
     * 找到相应位置并插入。
     * @param nums
     * @return
     */
    public  static int[] insertSort(int [] nums){
        if(nums.length<2|| nums==null)return nums;
        //方法一
        for (int i = 0; i < nums.length; i++) {
            int data = nums[i];//将当前元素进行保存
            int index = i;//下标
            //找到位置并往后移
            while(index > 0){
                if(data < nums[index-1]) {//后移
                    nums[index] = nums[index-1];
                }else {
                    break;
                }
                index--;
            }
            //插入数据
            nums[index] = data;
        }
        //方法二
        //在0-1上有序
        for (int i = 0; i < nums.length; i++) { //0-i 做到有序
            for (int j = i-1; j>=0&&nums[j]>nums[j+1]; j--) {
                swap(nums,j,j+1);
            }
        }
        return nums;
    }

异或 ^ 用法

在逻辑学中，逻辑算符异或（exclusive or）是对两个运算元的一种逻辑析取类型，符号为 XOR 或 EOR 或
⊕（编程语言中常用^）。但与一般的逻辑或不同，异或算符的值为真仅当两个运算元中恰有一个的值为真，而另外一个的值为非真。转化为命题，就是：“两者的值不同。”或“有且仅有一个为真。”

定义：

0^0=0
1^0=1
0^1=1
1^1=0

同时满足以下定律：

恒等律：X ⊕ 0 = X 归零律：X ⊕ X = 0 交换律 结合律

这里用到：不使用其他空间，交换两个值

  /**
     * 交换数组arr上i和j位置上的值
     * 原理：异或 ^  0^0=0;
     * 1^0=1
     * 同时异或满足与交换率和结合律
     * @param arr
     * @param i
     * @param j
     */
    public  static void swap(int[] arr,int i,int j){
        arr[i]=arr[i]^arr[j];
        arr[j]=arr[i]^arr[j];
        arr[i]=arr[i]^arr[j];
    }

更多用法：参考后续作品