• 【转】一道面试题注记


    以下内容转载自:http://www.blogjava.net/killme2008/archive/2010/10/28/336357.html

    ---------------------------------分割线开始--------------------------------------------

     javaeye的一个帖子介绍一道面试题,取数组的最大元素和前n个大元素,取最大元素很简单,遍历即可。取前N大元素,可以利用排序,最简单的实现:

     public static int[] findTopNValues(int[] anyOldOrderValues, int n) {
            Arrays.sort(anyOldOrderValues);
            int[] result = new int[n];
            System.arraycopy(anyOldOrderValues, anyOldOrderValues.length - n,
                    result, 0, n);
            return result;
        }

    Arrays.sort(int[])使用的是快排,平均的时间复杂度是O( n lg(n)),在一般情况下已经足够好。那么有没有平均情况下O(n)复杂度的算法?这个还是有的,这道题目其实是选择算法的变形,选择一个数组中的第n大元素,可以采用类似快排的方式划分数组,然后只要在一个子段做递归查找就可以,平均状况下可以做到O(n)的时间复杂度,对于这道题来说稍微变形下算法即可解决:

      /**
         * 求数组的前n个元素
         * 
         * @param anyOldOrderValues
         * @param n
         * @return
         */
        public static int[] findTopNValues(int[] anyOldOrderValues, int n) {
            int[] result = new int[n];
            findTopNValues(anyOldOrderValues, 0, anyOldOrderValues.length - 1, n,
                    n, result);
            return result;
        }
    
        public static final void findTopNValues(int[] a, int p, int r, int i,
                int n, int[] result) {
            // 全部取到,直接返回
            if (i == 0)
                return;
            // 只剩一个元素,拷贝到目标数组
            if (p == r) {
                System.arraycopy(a, p, result, n - i, i);
                return;
            }
            int len = r - p + 1;
            if (i > len || i < 0)
                throw new IllegalArgumentException();
            // if (len < 7) {
            // Arrays.sort(a, p, r+1);
            // System.arraycopy(a, r - i+1 , result, n - i, i);
            // return;
            // }
    
            // 划分
            int q = medPartition(a, p, r);
            // 计算右子段长度
            int k = r - q + 1;
            // 右子段长度恰好等于i
            if (i == k) {
                // 拷贝右子段到结果数组,返回
                System.arraycopy(a, q, result, n - i, i);
                return;
            } else if (k > i) {
                // 右子段比i长,递归到右子段求前i个元素
                findTopNValues(a, q + 1, r, i, n, result);
            } else {
                // 右子段比i短,拷贝右子段到结果数组,递归左子段求前i-k个元素
                System.arraycopy(a, q, result, n - i, k);
                findTopNValues(a, p, q - 1, i - k, n, result);
            }
        }
    
        public static int medPartition(int x[], int p, int r) {
            int len = r - p + 1;
            int m = p + (len >> 1);
            if (len > 7) {
                int l = p;
                int n = r;
                if (len > 40) { // Big arrays, pseudomedian of 9
                    int s = len / 8;
                    l = med3(x, l, l + s, l + 2 * s);
                    m = med3(x, m - s, m, m + s);
                    n = med3(x, n - 2 * s, n - s, n);
                }
                m = med3(x, l, m, n); // Mid-size, med of 3
            }
            if (m != r) {
                int temp = x[m];
                x[m] = x[r];
                x[r] = temp;
            }
            return partition(x, p, r);
        }
    
        private static int med3(int x[], int a, int b, int c) {
            return x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a)
                    : x[b] > x[c] ? b : x[a] > x[c] ? c : a;
        }
    
        public static void swap(int[] a, int i, int j) {
            int temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    
        public static int partition(int a[], int p, int r) {
            int x = a[r];
            int m = p - 1;
            int j = r;
            while (true) {
                do {
                    j--;
                } while (j>=p&&a[j] > x);
                do {
                    m++;
                } while (a[m] < x);
                
                if (j < m)
                    break;
                swap(a, m, j);
            }
            swap(a, r, j + 1);
            return j + 1;
        }

    选择算法还有最坏情况下O(n)复杂度的实现,有兴趣可以读算法导论和维基百科。题外,我测试了下这两个实现,在我的机器上大概有2倍多的差距,还是很明显。

    ----------------------------------------------分割线------------------------------------------------------------------------------------------------------

  • 相关阅读:
    java学习笔记(二)分布式框架Dubbo+zookeeper搭建
    java学习笔记(一) 服务器的认识
    用slf4j+logback实现多功能日志解决方案 --- 转
    9.3.2 The force and release procedural statements
    3.7.4 Tri0 and tri1 nets
    9.3.1 The assign and deassign procedural statements
    10. Tasks and functions
    6.1.2 The continuous assignment statement
    df 查看磁盘使用情况
    信息学竞赛知识点整理
  • 原文地址:https://www.cnblogs.com/GYoungBean/p/3336389.html
Copyright © 2020-2023  润新知