ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

排序

2022-09-07 13:30:46  阅读:156  来源: 互联网

标签:arr int 复杂度 length static 排序 public


一 插入排序

时间复杂度 O(n^2)

空间复杂度O(1)

稳定性:稳定

//插入排序
    public static void inSort(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            int tmp=arr[i];
            int j = i+1;
            for (; j >=0 ; j--) {
                if (arr[j]<tmp){
                    arr[j+1]=arr[j];
                }else {
                    break;
                }
            }
            arr[j+1]=tmp;

        }
    }

 

二 希尔排序

时间复杂度 O(n^1.3  --- n^1.5)

空间复杂度O(1)

稳定性:不稳定

 public static void shell(int[]arr,int gap){
        for (int i = 0; i < arr.length ; i++) {
            int j=i-gap;
            int tmp=arr[i];
            for (; j >=0 ; j-=gap) {
                if (tmp<arr[j]){
                    arr[j+gap]=arr[j];
                }else {
                   break;
                }
            }
            arr[j+ gap]=tmp;
        }
    }

    public static void shellSort(int[]arr){
        int gap= arr.length;
        if (gap>1){
            shell(arr,gap);
            gap/=2;
        }
        shell(arr,1);
    }

 

三 选择排序(两种方法)

时间复杂度 O(n^2)

空间复杂度O(1)

稳定性:不稳定

 

 //选择排序
    public static void choice(int[] arr){
        for (int i = 0; i < arr.length ; i++) {
            int j =i+1;
            for (; j < arr.length; j++) {
                if (arr[i]>arr[j]){
                    int tmp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=tmp;
                }
            }
        }

    }
    public static void choice1(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            int minindex=0;
            for (int j = 0; j < arr.length ; j++) {
                if (arr[j]<arr[minindex]){
                    minindex=j;
                }

            }
            swap(i,minindex,arr); //交换
        }
    }

 四 堆排序

时间复杂度 O(n*logn)

空间复杂度O(1)

稳定性:不稳定

/堆排序
    public static void haepSort(int[] arr){
        //建堆
        createHeap(arr);
        int end= arr.length-1;
        //交换然后调整
        while (end>0){
            swap(0,end,arr);
            shiftDown(arr,0,end);
            end--;
        }
    }
    public static void createHeap(int[] array){
        for (int parent = (array.length-1-1)/2; parent >=0 ; parent--) {
            shiftDown(array,parent,array.length);
        }
    }

    public static void shiftDown(int[] arr,int parent,int len){
        int child=2*parent+1; //左孩子下标
        while (child<len){
            if (child+1<len && arr[child]<arr[child+1]){
                child++; //child下标是左右孩子最大值的下标
            }
            if (arr[child]>arr[parent]){
                swap(child,parent,arr);
                parent=child;
                child=2*parent+1;
            }else {
                break;
            }
        }
    }

    public static void swap(int i,int j,int[]arr){
        int tmp=arr[i];
        arr[i]=arr[j];
        arr[j]=tmp;
    }

五 冒泡排序

时间复杂度 O(n*logn)

空间复杂度O(1)

稳定性:不稳定 

 public static void bublSort(int[] arr){
for (int i = 0; i < arr.length-1 ; i++) { boolean tmp =false; for (int j = 0; j < arr.length-1-i ; j++) { if (arr[j+1]<arr[j]){ swap(j,j+1,arr); tmp=true; } } if (tmp=false){ break; } }
}

 

六 快速排序

时间复杂度 最好 O(n*logn)  最坏 O(n^2)

空间复杂度 最好O(logn)   最坏 O(n)

稳定性:不稳定  

 

 

 public static void quickSort(int[] arr){
        quick(arr,0, arr.length-1);
    }
    public static void quick(int[] arr,int left,int right){
        if (left>=right){
            return;
        }
        int pivot =partition(arr, left, right);
        quick(arr,left,pivot-1);
        quick(arr,pivot+1,right);
    }
    public static int partition(int[] arr,int left,int right){
        int tmp=arr[left];
        while (left<right){
            while (left<right && tmp<=arr[right]){
                right--;
            }
            arr[left]=arr[right];
            while ((left<right && tmp>= arr[left])){
                left++;
            }
            arr[right]=arr[left];
        }
        arr[left]=tmp;
        return tmp;

    }

 

标签:arr,int,复杂度,length,static,排序,public
来源: https://www.cnblogs.com/lbwboke/p/16664581.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有