Java实现选择排序算法

简单选择排序

//交换数组两个位置的数
    static void swap(int[] arr,int i,int j){
        int temp;
        temp=arr[j];
        arr[j]=arr[i];
        arr[i]=temp;
    }

    //简单选择排序算法
    static void SimpleSelectSort(int[] arr,int length){
        int i,j,min;
        //进行n-1趟，从头到尾排序
        for (i=0;i<length-1;i++){
            //确定要寻找最小值的当前位置
            min=i;
            //寻找当前位置与之后元素的最小值
            for (j=i+1;j<length;j++){
                //如果有最小值出现，则更新最小值的指针
                if(arr[j]<arr[min])
                    min=j;
            }
            //如果当前位置i的指针与最小值的指针不同，说明当前位置的值不是最小值，所以要交换
            if (min!=i)
                swap(arr,i,min);
        }
    }

选择排序算法的基本思想是：每一趟（如第i趟）在后面n-i+1(i=1,2,…,n-1)个待排序元素中选取关键字最小的元素，作为有序子序列的第i个元素，直到第i-1趟做完，待排序元素只剩下一个，就不用再选了。

空间复杂度：O(1)。
时间复杂度：O(n^2)。

**

堆排序

**

//构建大根堆
    static void BulidMaxHeap(int arr[],int length){
        //从最后一个非叶子结点开始往上调整
        for (int i=length>>1;i>0;i--){
            HeadAdjust(arr,i,length);
        }
    }

    //从根结点往下调整大根堆
    static void HeadAdjust(int arr[],int index,int length){
        //暂存根节点
        arr[0]=arr[index];
        int i;
        //寻找当前结点的左孩子结点
        for (i=index<<1;i<=length;i=i<<1){
            //如果当前结点有右兄弟，则比较哪个大
            if (i<length&&arr[i]<arr[i+1])
                //右兄弟比较大，移动指针
                i++;
            //比较根节点是否大于右兄弟以满足大根堆的特性
            if (arr[0]>arr[i])
                break;
            //如果不满足大根堆的特性，则父子结点相互交换
            else {
                arr[index]=arr[i];
                index=i;
            }
        }
        //父结点落入最终位置
        arr[index]=arr[0];
    }

    //堆排序
    static int[] HeapSort(int[] arr,int length){
        arr=ArrayAdjust(arr);
        //构建初始大根堆
        BulidMaxHeap(arr,length);
        //进行n-1趟的交换以及建堆
        for (int i=length;i>1;i--){
            //堆顶元素和堆底元素交换，然后输出堆顶元素，因为此时堆顶元素为最小值。
            swap(arr,i,1);
            // 把剩余的i-1个元素调整大根堆
            HeadAdjust(arr,1,i-1);
        }
        arr=ArrayRest(arr);
        return arr;
    }

    //将数组头部加个-1，方便堆排序中arr[0]存放根节点元素
    static int[] ArrayAdjust(int[] arr){
        int[] temp=new int[arr.length+1];
        temp[0]=-1;
        for (int i=1;i<temp.length;i++){
            temp[i]=arr[i-1];
        }
        return temp;
    }

    //把数组arr[0]元素去掉，还原数组
    static int[] ArrayRest(int[] arr){
        int[] temp=new int[arr.length-1];
        for (int i=0;i<temp.length;i++){
            temp[i]=arr[i+1];
        }
        return temp;
    }

可以将一维数组看作一个完全二叉树，满足每个非叶子结点的值都大于对应左右孩子的值，这种树称为大根堆。
待排序的思路：首先将arr[0~length-1]构成初始堆，由于堆本身的特点，堆顶元素就是最大值，然后与堆底元素(为最小值)进行交换，继续调整剩余的i-1个元素为大根堆。

空间复杂度：O(1)
时间复杂度😮(nlog2n),其中建堆时间为O(n),每次调整时间为O(h)，也就是当前二叉树的树高，根据二叉树的高度与结点关系，h=log2n