zoukankan      html  css  js  c++  java
  • 排序算法总结

    排序算法比较

    https://www.cnblogs.com/bjwu/articles/10006419.html

    冒泡排序

     1     /**冒泡排序
     2      * 第一次比较0~N-1位 将最大值沉底
     3      * 第二次比较0~N-2位 将最大值沉底
     4      * ......
     5      * 第N-1次比较0~1位 将最大值沉底(在0~1中沉底)
     6      * 时间复杂度:O(n^2)
     7      */
     8     public static void sort(int[] nums){
     9         if(nums == null || nums.length < 2){
    10             return;
    11         }
    12         for(int end = nums.length-1; end > 0; end--){
    13             for(int j = 0; j < end; j++){
    14                 if(nums[j] > nums[j+1]){
    15                     swap(nums,j,j+1);
    16                 }
    17             }
    18         }
    19 
    20     }
    21     public static void swap(int[] nums, int i, int j){
    22         int tmp = nums[i];
    23         nums[i] = nums[j];
    24         nums[j] = tmp;
    25     }

    插入排序

     1     /** 插入排序
     2      *  0~end-1 位置的数都有序
     3      *  每次考察end位置的数应该插在哪里
     4      *  如果前面的数比end位置数大则交换
     5      *
     6      *  插入选择时间复杂度和数据样本无关
     7      *  插入排序 有序 O(n) 逆序O(n^2)
     8      *  时间复杂度按最差的算
     9      *  所以插入排序的时间复杂度是O(n^2)
    10      */
    11     public static void sort(int[] nums){
    12         for(int end = 1; end < nums.length; end++){
    13             for(int i = end-1; i >= 0; i--){//与前面有序部分比较是否能够交换
    14                 if(nums[i] > nums[i+1]){
    15                     swap(nums,i,i+1);
    16                 }
    17             }
    18         }
    19     }
    20 
    21     public static void swap(int[] nums, int i, int j){
    22         int tmp = nums[i];
    23         nums[i] = nums[j];
    24         nums[j] = tmp;
    25     }

    选择排序

        /**选择排序
         * 第一次比较 0~N-1 找到最小值的位置和0交换
         * 第二次比较 1~N-2 找到最小值的位置和1交换
         * ......
         * 第N-1次比较 N-2~N 找到最小值的位置和N-2交换
         * 时间复杂度:O(N^2)
         */
        public static void sort(int[] nums){
            if(nums == null || nums.length < 2){
                return;
            }
            for(int start = 0; start < nums.length; start++){
                int minIndex = start;
                for(int i = start; i < nums.length; i++){
                    minIndex = nums[i] < nums[minIndex]? i:minIndex;
                }
                swap(nums, minIndex, start);
            }
    
        }
    
        public static void swap(int[] nums, int i, int j){
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }

    快排

     1     public static void quickSort(int [] nums, int left, int right){
     2         if (nums == null || nums.length < 2) {
     3             return;
     4         }
     5         if(left < right){
     6             //随机选一个位置和最后一个数字交换
     7             swap(nums, left+(int)Math.random()*(right-left+1), right);
     8             int[] p = partition(nums, left, right);//等于区域的左边界和右边界
     9             quickSort(nums, left, p[0]-1); // 小于区域递归
    10             quickSort(nums, p[1]+1, right); // 大于区域递归
    11         }
    12     }
    13 
    14     public static int[] partition(int[] nums, int left, int right){
    15         int smaller = left - 1; // 小于区域的右边界
    16         int bigger = right; // 大于区域的左边界
    17         while(left < bigger){
    18             int target = nums[right];
    19             if(nums[left] > target){
    20                 swap(nums,left,bigger-1);
    21                 bigger--;
    22             }else if(nums[left] < target){
    23                 swap(nums,left,smaller+1);
    24                 smaller++;
    25                 left++;
    26             }else {
    27                 left++;
    28             }
    29         }
    30         swap(nums, bigger, right);
    31         return new int[]{smaller+1,bigger};
    32     }
    33     public static void swap(int[] nums, int i, int j){
    34         int tmp = nums[i];
    35         nums[i] = nums[j];
    36         nums[j] = tmp;
    37     }

    归并排序

     1     /**归并排序
     2      * 左边排序 右边排序
     3      * 外排整体排序 辅助数组
     4      * 左边有序数组和右边有序数组谁小谁加入辅助数组
     5      * T(N) = 2T(N/2) + O(N)
     6      * log2(2) = 1 = d -->
     7      * 时间复杂度为 O(N*logN)
     8      */
     9     public static void mergeSort(int[] nums){
    10         if(nums ==null || nums.length < 2){
    11             return;
    12         }
    13         sortProcess(nums, 0, nums.length-1);
    14     }
    15     public static void sortProcess(int[] nums, int left, int right){
    16         if(left == right){//结束递归条件 这个范围只有一个数
    17             return;
    18         }
    19         int mid = left + (right - left)/2;
    20         sortProcess(nums,left,mid);//左边有序 T(N/2)
    21         sortProcess(nums,mid+1,right);//右边有序 T(N/2)
    22         merge(nums, left, mid, right);//外排序 O(N)
    23     }
    24 
    25     public static void merge(int[] nums, int left, int mid, int right){
    26         int[] help = new int[right-left+1];//left到right有多少个数
    27         int i = 0;//指向help
    28         int p1 = left;//指向左侧数组第一个数
    29         int p2 = mid+1;//指向右侧数组第一个数
    30 
    31         while(p1 <= mid && p2 <= right){//有一个数组读完了就退出循环
    32             //哪边小哪边的p指向的元素加入help 加入之后移动p指针
    33             help[i++] = nums[p1] < nums[p2] ? nums[p1++] : nums[p2++];
    34         }
    35         //只有一个越界 把剩余的数组一次性添加进help
    36         while(p2 <= right){
    37             help[i++] = nums[p2++];
    38         }
    39         while(p1 <= mid){
    40             help[i++] = nums[p1++];
    41         }
    42         //将help中的依次覆盖nums
    43         for(int j = 0; j < help.length; j++){
    44             nums[left+j] = help[j];
    45         }
    46     }

    逆序和  & 最小和都可以用归并排序的思路来解

    逆序对

     1 /**
     2  * 逆序对和最小和求解思路的区别
     3  *
     4  * 【最小和】是优先找小值
     5  * [1,1,2] [2,3,4]
     6  * 优先在左侧数组找到小值后  右边剩下的就都比该值要大了 从左向右遍历
     7  * 例如:对于左边第一个元素1 右边第一个元素2及2之后的所有元素都对1有一个小和
     8  * smallsum += 1 * (right-p2+1)
     9  * 即 如果左小于右 累加
    10  *
    11  * 【逆序对】要求是左侧元素大于右侧
    12  * 优先在左侧找大值 对于升序排序 大值在最右边 应该从右向左遍历
    13  * [1,1,5] [1,3,4]
    14  * 例如:对于左边最后一个元素5 大于右边最后一个元素4 则5可以和4及4之前的所有元素形成一个逆序对
    15  * [5,1][5,3][5,4]
    16  * count += right-(mid+1)+1  5 - 3 + 1 = 3 个
    17  * 即 如果左大于右 累加
    18  */
    19 public class ReversePair {
    20     private static int count;
    21     private static List<int[]> list = new ArrayList<>();
    22     public static void mergeSort(int[] nums){
    23         if(nums ==null || nums.length < 2){
    24             return;
    25         }
    26         sortProcess(nums, 0, nums.length-1);
    27     }
    28     public static void sortProcess(int[] nums, int left, int right){
    29         if(left == right){//结束递归条件 这个范围只有一个数
    30             return;
    31         }
    32         int mid = left + (right - left)/2;
    33         sortProcess(nums,left,mid);//左边有序 T(N/2)
    34         sortProcess(nums,mid+1,right);//右边有序 T(N/2)
    35         merge(nums, left, mid, right);//外排序 O(N)
    36     }
    37 
    38     public static void merge(int[] nums, int left, int mid, int right){
    39         int[] helper = new int[right -left + 1];
    40         int p = right - left;
    41         int rightBegin = mid + 1;
    42         while(left <= mid && rightBegin <= right){
    43             if(nums[mid] > nums[right]){
    44                 count += (right - rightBegin)+1;
    45                 for(int k = right; k >= rightBegin; k--){
    46                     list.add(new int[] {nums[mid],nums[k]});
    47                 }
    48                 helper[p--] = nums[mid--];
    49             }else{
    50                 helper[p--] = nums[right--];
    51             }
    52         }
    53         while(left <= mid){
    54             helper[p--] = nums[mid--];
    55         }
    56         while(right >= rightBegin){
    57             helper[p--] = nums[right--];
    58         }
    59         for(int help:helper){
    60             nums[left++] = help;
    61         }
    62     }
    63 
    64     public static void main(String[] args) {
    65         int[] nums = {3,5,4,2,1};
    66         mergeSort(nums);
    67         System.out.println(Arrays.toString(nums));
    68         System.out.println(count);
    69         for(int[] pair: list){
    70             System.out.println(Arrays.toString(pair));
    71         }
    72     }
    73 }

    最小和

     1 public class SmallSum {
     2     public static int smallSum(int[] arr){
     3         if(arr == null|| arr.length < 2){
     4             return 0;
     5         }
     6         return mergeSort(arr,0,arr.length-1);
     7     }
     8 
     9     /**
    10      * 计算left ~ right范围内有多少小和
    11      */
    12     public static int mergeSort(int[] arr, int left, int right){
    13         if(left == right){
    14             return 0;
    15         }
    16         int mid = left + ((right - left) >> 1); //右移1位 等于 除以2
    17         //mid = left + (right - left)/2; 防止溢出
    18         return mergeSort(arr, left, mid)+//左边排序产生的小和
    19                 mergeSort(arr, mid+1, right)+//右边排序产生的小和
    20                 merge(arr, left, mid, right);//最后合并产生的小和
    21     }
    22 
    23     public static int merge(int[] arr, int left, int mid, int right){
    24         int[] help = new int[right-left+1];//准备一个临时数组
    25         // 长度和传进来的arr一样 是原arr的一部分 用left和right划分出来的一部分
    26         int i = 0;
    27         int p1= left;
    28         int p2 = mid+1;
    29         int res = 0;//计算小和
    30         while(p1 <= mid && p2 <= right){
    31             //关键在这里:
    32             // 每一次比较可以知道比当前值更大的值有几个,这个较小的当前值就需要累加多少次。
    33             //如果左边小于右边,那就有(r - p2 + 1)个arr[p1]元素的和是最小和,进行累加。
    34             //p2后面的个数 * p1指向的数
    35             res += arr[p1] < arr[p2] ? (right - p2 + 1) * arr[p1] : 0;
    36             help[i++] = arr[p1] > arr[p2] ? arr[p2++] : arr[p1++];
    37         }
    38         while(p1 <= mid){
    39             help[i++] = arr[p1++];
    40         }
    41         while (p2 <= right){
    42             help[i++] = arr[p2++];
    43         }
    44         for(i = 0; i < help.length; i++){
    45             arr[left+i] = help[i];
    46         }
    47         return res;
    48     }
    49 
    50     public static void main(String[] args) {
    51         int[] nums = {1,3,4,2,5};
    52         int i = smallSum(nums);
    53         System.out.println(i);
    54     }
    55 }

    堆排序

    /**
     * HeapSort展示了heapinsert和heapify的两个过程
     * 时间复杂度是O(NlogN)
     * 实际上可以只用heapify
     * 用heapify代替heapinsert从后向前heapify
     * 原来的heapinsert是O(NlogN) heapify时间复杂度是O(N) 可以稍微快一点
     * 但最后的时间复杂度还是O(NlogN) 因为后面的操作还是O(NlogN)
     */
    public class HeapSort {
        //堆化【调整堆】 某个数在index值 能否往下移动
        public static void heapify(int[] nums, int index, int heapSize){
            //index是初始的父节点
            int left = index * 2 + 1; //左孩子
            while(left < heapSize){//下方还有孩子时 没有越界
                int largest = left;
                if(left + 1 < heapSize) {//右孩子存在 没有越界
                    //左右两孩子PK
                    largest = nums[left]>nums[left+1]?left:left+1;
                }
                //较大孩子和父亲PK
                largest = nums[index]>nums[largest]?index:largest;
                //父亲最大不交换
                if(largest == index){
                    break;
                }
                //父亲和较大孩子交换
                swap(nums, largest, index);
                //下一个比较的数 新父亲
                index = largest;
                //交换后的新的左孩子
                left = index * 2 + 1;
            }
        }
    
        /**
         * 无序数组 相当于依次插入大根堆 heapinsert
         * 得到大根堆后
         * 每次让数组第一个元素(最大值)和最后一个元素交换
         * 交换后heapsize--,调整堆heapify为大根堆
         * 最后heapsize == 0 数组有序
         */
        public static void heapSort(int[] nums){
            if(nums == null || nums.length < 2){
                return;
            }
            for (int i = nums.length-1; i >= 0; i--) {
                heapify(nums,i,nums.length);
            }
            int heapSize = nums.length;
            swap(nums,0,--heapSize);//先交换
            while(heapSize > 0){
                heapify(nums,0,heapSize);//再堆化
                swap(nums,0,--heapSize);//继续交换
            }
        }
    
        public static void swap(int[] nums, int i, int j){
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
    
        public static void main(String[] args) {
            int[] nums = {2,3,1,4,4,3,3,4,5,1};
            heapSort(nums);
            System.out.println(Arrays.toString(nums));
        }
    }

    适用于求基本有序的数列

     * 已知一个几乎有序的数组,几乎有序是指,
     * 如果把数组排好顺序的话,每个元素移动的距离可以不超过K
     * 可以用堆排序来解决这个问题
     *
     * 思路:
     * 1.建立有K个元素的小顶堆,然后取出顶上元素
     * 2.堆顶用没有建堆的下一元素替代,重新建堆
     * 3.反复调用,完成排序,此算法因为每个元素移动都在k以内,所以时间复杂度为O(NlogK)
     */
    public class KHeapSort {
    
        public static void kHeapSort(int[] nums, int k) {
            PriorityQueue<Integer> heap = new PriorityQueue<>();
            int index= 0;
            //k个值加入堆
            for(; index <= Math.min(k, nums.length); index++){
                heap.add(nums[index]);
            }
            int i = 0;
            //从index的下一个位置开始遍历 也就是k+1
            for(; index < nums.length; i++,index++){
                heap.add(nums[index]);//加一个 heapsize+1
                nums[i] = heap.poll();//弹一个 heapsize-1
            }
            while (!heap.isEmpty()){
                nums[i++] = heap.poll();
            }
    
        }
    
        public static void main(String[] args) {
            int [] nums ={3,2,7,1,8,6,4,5,12,10,15,9,13,14,11,20,16,17,18,19};
            kHeapSort(nums,7);
            System.out.println(Arrays.toString(nums));
        }
    }

    基数排序

    public class RadixSort {
        /**
         * 统计最大值有多少位
         */
        public static int maxbits(int[] nums){
            int max = nums[0];
            for(int i = 0; i < nums.length; i++){
                max = Math.max(nums[i], max);
            }
            int count = 0;
            while(max > 0){
                max /= 10;
                count++;
            }
            return count;
        }
        /**
         * 获取倒数第i位的数字 i=1 取出个位
         */
        public static int getDigit(int num,int i){
            while(i > 1){
                num /= 10;
                i--;
            }
            return num%10;
        }
    
        /**
         * 基数排序
         */
        public static void radixSort(int[] arr){
            int digit = maxbits(arr);
            //基数 10
            final int radix = 10;
            //给每个数准备一个桶
            int[] buckets = new int[arr.length];
            //有多少位 就要出桶进桶几次
            for(int d = 1; d <= digit; d++){
                //计数器 等于count的有几个
                int[] count = new int[radix];
                for(int i = 0; i < arr.length; i++){
                    int j = getDigit(arr[i],d);
                    count[j]++;
                }
                //将count变为前缀和 小于等于count的有几个
                for(int i = 1; i < radix; i++){
                    count[i] += count[i-1];
                }
                System.out.println(Arrays.toString(count));
    
                //数组从右向左遍历 入桶
                for(int i = arr.length-1; i >=0; i--){
                    int j = getDigit(arr[i],d);
                    buckets[count[j]-1] = arr[i];
                    count[j]--;
                }
    
                //当前位数出桶
                for(int i = 0; i < arr.length; i++) {
                    arr[i] = buckets[i];
                }
            }
        }
    
        public static void main(String[] args) {
            int[] nums = {123,423,19,32,321,1200};
            radixSort(nums);
            System.out.println(Arrays.toString(nums));
        }
    }
  • 相关阅读:
    Java母牛繁殖问题
    【转】区块链交易的并发执行
    Cinder 架构分析、高可用部署与核心功能解析
    【转】区块链的隐私保护方案介绍
    如何在ES6中判断类中是否包含某个属性和方法
    阿里云MySQL及Redis灵异断连现象:安全组静默丢包解决方法
    如何区别ES5和ES6创建类(异同点)
    这两家独角兽企业在强敌缠斗中崛起
    来看一看那些已经倒闭的互联网公司
    《并行计算的编程模型》一3.6.1 全局同步屏障
  • 原文地址:https://www.cnblogs.com/xdcat/p/13048132.html
Copyright © 2011-2022 走看看