面试常见算法

好东西-算法

寻找最小的k个数

题目描述

输入n个整数，输出其中最小的k个。

解法一：快排

要求一个序列中最小的k个数，按照惯有的思维方式，则是先对这个序列从小到大排序，然后输出前面的最小的k个数。

至于选取什么的排序方法，我想你可能会第一时间想到快速排序（我们知道，快速排序平均所费时间为 n*logn ），然后再遍历序列中前k个元素输出即可。因此，总的时间复杂度： O（n * log n)+O(k)=O（n * log n） 。

缺点：
当K=1时，复杂度也是O(n*logn),对所有元素进行排序。
取出的最小k个数也是有序的。

而应当问清楚，最小的K个数，需不需要有序，以及K的大小。

解法二：冒泡/选择部分排序

咱们再进一步想想，题目没有要求最小的k个数有序，也没要求最后n-k个数有序。既然如此，就没有必要对所有元素进行排序。这时，咱们想到了用选择或交换排序，即：

1. 遍历n个数，把最先遍历到的k个数存入到大小为k的数组中，假设它们即是最小的k个数；
2. 对这k个数，利用选择或交换排序找到这k个元素中的最大值kmax（找最大值需要遍历这k个数，时间复杂度为 O（k） ）；
3. 继续遍历剩余n-k个数。假设每一次遍历到的新的元素的值为x，把x与kmax比较：如果 x < kmax ，用x替换kmax，并回到第二步重新找出k个元素的数组中最大元素kmax‘；如果 x >= kmax ，则继续遍历不更新数组。

每次遍历，更新或不更新数组的所用的时间为 O（k） 或 O（0） 。故整趟下来，时间复杂度为 n*O（k）=O（n*k） 。

这种前k个数是无序的。

若直接用交换排序（冒泡）或选择排序的部分排序，复杂度也为O(N*K),但是前K个元素有序 。

解法一的复杂度为O（N*logN）
解法二的复杂度为O(N*K)

解法的优劣取决于K的大小。需要在面试者那里弄清楚。在K较小（<=logN），可以选择部分排序。

解法三:堆

当N特别大的时候，比如100亿？，这个时候数据不能全部装入内存，所以要求尽可能少地遍历所有数据。

这时可以用堆。
求最小k个数，用容量为K的大顶堆。
求最大k个数，用容量为K的小顶堆。

更好的办法是维护容量为k的最大堆，原理跟解法二的方法相似：

1. 用容量为k的最大堆存储最先遍历到的k个数，同样假设它们即是最小的k个数；
2. 堆中元素是有序的，令k1 < k2 <… < kmax（kmax设为最大堆中的最大元素）
3. 遍历剩余n-k个数。假设每一次遍历到的新的元素的值为x，把x与堆顶元素kmax比较：如果 x < kmax ，用x替换kmax，然后更新堆（用时logk）；否则不更新堆。

这样下来，总的时间复杂度: O（k+（n-k）*logk）=O（n*logk） 。此方法得益于堆中进行查找和更新的时间复杂度均为： O(logk) （若使用解法二：在数组中找出最大元素，时间复杂度： O（k）） 。

此算法只需要扫描所有数据一次。空间上，大部分情况，堆可以全部载入内存。若k仍然很大，不能一次全部装入内存，那就先找最小的k’个元素，然后找第k’+1到第2*k’个元素，依次类推。

解法四：快速选择

在《数据结构与算法分析–c语言描述》一书，第7章第7.7.6节中，阐述了一种在平均情况下，时间复杂度为 O（N） 的快速选择算法。如下述文字：

选取S中一个元素作为枢纽元v，将集合S-{v}分割成S1和S2，就像快速排序那样
如果k <= |S1|，那么第k个最小元素必然在S1中。在这种情况下，返回QuickSelect(S1, k)。
如果k = 1 + |S1|，那么枢纽元素就是第k个最小元素，即找到，直接返回它。
否则，这第k个最小元素就在S2中，即S2中的第（k - |S1| - 1）个最小元素，我们递归调用并返回QuickSelect(S2, k - |S1| - 1)。
此算法的平均运行时间为O(n)。

示例代码如下：

//QuickSelect 将第k小的元素放在 a[k-1]  
void QuickSelect( int a[], int k, int left, int right )
{
    int i, j;
    int pivot;

    if( left + cutoff <= right )
    {
        pivot = median3( a, left, right );
        //取三数中值作为枢纽元，可以很大程度上避免最坏情况
        i = left; j = right - 1;
        for( ; ; )
        {
            while( a[ ++i ] < pivot ){ }
            while( a[ --j ] > pivot ){ }
            if( i < j )
                swap( &a[ i ], &a[ j ] );
            else
                break;
        }
        //重置枢纽元
        swap( &a[ i ], &a[ right - 1 ] );  

        if( k <= i )
            QuickSelect( a, k, left, i - 1 );
        else if( k > i + 1 )
            QuickSelect( a, k, i + 1, right );
    }
    else  
        InsertSort( a + left, right - left + 1 );
}

这个快速选择SELECT算法，类似快速排序的划分方法。N个数存储在数组S中，再从数组中选取“中位数的中位数”作为枢纽元X，把数组划分为Sa和Sb俩部分，Sa<=X<=Sb，如果要查找的k个元素小于Sa的元素个数，则返回Sa中较小的k个元素，否则返回Sa中所有元素+Sb中小的k-|Sa|个元素，这种解法在平均情况下能做到 O(n) 的复杂度。

更进一步，《算法导论》第9章第9.3节介绍了一个最坏情况下亦为O(n)时间的SELECT算法，有兴趣的读者可以参看。随机快速选择算法。

举一反三

1、谷歌面试题：输入是两个整数数组，他们任意两个数的和又可以组成一个数组，求这个和中前k个数怎么做？

分析：

“假设两个整数数组为A和B，各有N个元素，任意两个数的和组成的数组C有N^2个元素。
那么可以把这些和看成N个有序数列：
A[1]+B[1] <= A[1]+B[2] <= A[1]+B[3] <=…
A[2]+B[1] <= A[2]+B[2] <= A[2]+B[3] <=…
…
A[N]+B[1] <= A[N]+B[2] <= A[N]+B[3] <=…
问题转变成，在这N^2个有序数列里，找到前k小的元素”
2、有两个序列A和B,A=(a1,a2,…,ak),B=(b1,b2,…,bk)，A和B都按升序排列。对于1<=i,j<=k，求k个最小的（ai+bj）。要求算法尽量高效。

3、给定一个数列a1,a2,a3,…,an和m个三元组表示的查询，对于每个查询(i，j，k)，输出ai，ai+1，…，aj的升序排列中第k个数。

出现次数超过一半的数字

解法一：
数组排序，然后中间值肯定是要查找的值。 排序最小的时间复杂度（快速排序）O(NlogN)，加上遍历。
解法二：
使用散列表（HashMap）的方式，也就是统计每个数组出现的次数，输出出现次数大于数组长度的数字。

解法三：
本题O(n)的思想是，定义两个变量temp和count，每次循环时，如果array[i]的值等于temp，则count自增一，如不等并且count>0，则count自减一，若array[i]的值不等于temp并且count不大于0，重新对temp赋值为当前array[i]，count赋值为1。
如存在大于一半的数，直接返回temp就是了，但测试数据中有不存在的情况，所以最后又来了一遍校验，检查当前temp值是否出现过一半以上。

public int MoreThanHalfNum_Solution(int [] array) {  
        if (array.length==0) return 0;  
        int num = array[0];  
        int count = 0;  
        for (int i = 0; i < array.length; i++) {  
            if(array[i]==num)  
                count++;  
            else  
                count--;  
            if(count==0)  
            {  
                num = array[i];  
                count=1;  
            }  

        }  

        count = 0;  
        for (int i = 0; i < array.length; i++) {  
            if(array[i]==num) count++;  
        }  
        if(count*2>array.length) return num;  
        return 0;  
    }  

丑数

题目描述

把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

import java.util.ArrayList;
public class Solution {
    public int GetUglyNumber_Solution(int index) {

        ArrayList list=new ArrayList();

        if(index<1)
            return 0;

        list.add(1);
        int a=0;
        int b=0;
        int c=0;
        int count=1;
        while(countint min=Math.min(Math.min(list.get(a)*2,list.get(b)*3),list.get(c)*5);

            if(min==list.get(a)*2)
                a++;
            if(min==list.get(b)*3)
                b++;
            if(min==list.get(c)*5)
                c++; 

            count++;
            list.add(min);

        }

        return list.get(index-1);
    }
}