基础复习统计之排序算法 代码 JAVA版

做个统计笔记，这里不做分析
测试用例
int a[]={5,9,8,3,1,7,2,4,6};

选择排序

选定i位置，找寻i后面的最小元素与i位置交换以此类推

   public int[] selectsort(int nums[]){
        for (int i = 0; i <nums.length ; i++) {
            //获取当前元素，看作最小值
            int min=nums[i];
            //标记下标位
            int index=i;
            for (int j = i; j <nums.length ; j++) {
                //如果比最小值小，则将该值赋值给最小值
                if (nums[j]<min){
                    min=nums[j];
                    //获取该值下标
                    index=j;
                }
            }
            //将最小值与该位置交换
            int demp=nums[i];
            nums[i]=nums[index];
            nums[index]=demp;
            System.out.println(Arrays.toString(nums));
        }
        return nums;
    }

输出:

冒泡排序

从头到尾比较，比他大的放该位置依次类推

 public int[] bubblesort(int nums[]){
        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]) {
                    int temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
        return nums;
    }

输出：

插入排序

选定 i 的前元素作为已经排序好的数组 从 i 位置往前找直到找到比 nums[j]小的数，排在其后面，j 到 i-1 的位置往后移

  public int[] insertionsort(int nums[]){
        for (int i = 0; i <nums.length ; i++) {
            for (int j = i; j >0 ; j--) {
                if (nums[j]<nums[j-1]){
                    int demp=nums[j-1];
                    nums[j-1]=nums[j];
                    nums[j]=demp;
                }
            }
            System.out.println(Arrays.toString(nums));
        }
        return nums;
    }

输出：

快速排序

采用分治的思想，将最左的值作为基准数，先从右边找比基准数小的停止，再从左边找比他大的停止，交换这两个值，直到 i=j ，然后将这个值与基准数交换，再从这个值开始分成两个数组再进行一次同样步骤，直到左边下标大于右边下标，也就代表只有一个数的时候,这里为什么不是用等于呢，是因为i=j了，下一次递归是i+1->rigth,或者left->i-1

//快速排序
    public void quersort(int []nums,int left,int rigth){
        if (left>rigth)return;
        int i=left;
        int j=rigth;
        int index=nums[left];
        while (i!=j){
            while (i<j&&nums[j]>=index){
                j--;
            }
            while (i<j&&nums[i]<=index){
                i++;
            }
            int temp=nums[i];
            nums[i]=nums[j];
            nums[j]=temp;
        }
        nums[left]=nums[i];
        nums[i]=index;
        quersort(nums,i+1 ,rigth);
        quersort(nums,left,i-1);
    }

输出：

堆排序

堆排序是根据二叉树思想，由大顶堆（所有父节点大于子节点，左子节点大于右子节点）划数组。第一步是先建立大顶堆，再将root结点赋值给数组最后一位，再将数组长度减一，父节点下标可表示为i , 左子节点下标为i2+1
右子节点下标为i2+2，父结点相对左,右子节点下标为(i-1)/2,根节点坐标为n/2-1

   public void heapify(int nums[],int n,int i){
        int root=i;
        int left=i*2+1;
        int rigth=i*2+2;
        if (left<n&&nums[left]>nums[root]){
            root=left;
        }
        if (rigth<n&&nums[rigth]>nums[root]){
            root=rigth;
        }
        if (root!=i){
            int demp=nums[i];
            nums[i]=nums[root];
            nums[root]=demp;
            heapify(nums,n,root);
        }
    }

    //堆排序
    public void hepa(int nums[],int n){
        //建堆
        for (int i =n/2-1 ; i >=0 ; i--) {
            heapify(nums,n,i);
        }
        //排序
        for (int i = n-1; i >=0 ; i--) {
            int demp=nums[i];
            nums[i]=nums[0];
            nums[0]=demp;
            heapify(nums,i,0);
        }
    }

输出：

归并排序

讲究先分再合，分到只有一个元素时开始比较并合并，小的就放在前面大的放在后面，一步一步倒着合并。

  //合并
    public void merge(int nums[],int demparr[],int left,int mid,int rigth){

        //左半区第一元素
        int l=left;
        //右半区第一个元素
        int r=mid+1;
        //数组下标，从nums[0]->nums[nums.length-1]
        int index=left;

        //将左半部分和右半部分比较并合并
        while (l<=mid&&r<=rigth){
            if (nums[l]<nums[r]){
                demparr[index]=nums[l];
                index++;
                l++;
            }else {
                demparr[index]=nums[r];
                index++;
                r++;
            }
        }
        //合并完毕后会有剩余元素未比较，要不左半部分剩余，要不右半部份剩余，所以需要将剩余元素合并

        //如果左边的部分还没完那么就将右部分直接合并
        while(l<=mid){
            demparr[index]=nums[l];
            index++;
            l++;
        }
        //如果右边的部分还没完那么就将右部分直接合并
        while(r<=rigth){
            demparr[index]=nums[r];
            index++;
            r++;
        }
        //复制辅助数组元素入主数组
        while (left<=rigth){
            nums[left]=demparr[left];
            left++;
        }
    }
    //划分
    public void divide(int nums[],int demparr[],int left,int rigth){

        //如果说左边小于右边，说明有两个数以上，需要继续划分
        if (left<rigth){
            //获取中间项
            int mid=(left+rigth)/2;
            //左部分从left->mid
            divide(nums,demparr,left,mid);
            //右部分从mid+1->rigth
            divide(nums,demparr,mid+1,rigth);
            //分完之后再比较合并
            merge(nums,demparr,left,mid,rigth);
        }
    }
    //归并排序
    public int[] mergesort(int nums[]){
        int n=nums.length;
        int demparr[]=new int[n];
        divide(nums,demparr,0,n-1);
        return nums;
    }

输出：