Interview Questions: Quicksort

Quicksort

Nuts and bolts. A disorganized carpenter has a mixed pile of n nuts and n bolts. The goal is to find the corresponding pairs of nuts and bolts. Each nut fits exactly one bolt and each bolt fits exactly one nut. By fitting a nut and a bolt together, the carpenter can see which one is bigger (but the carpenter cannot compare two nuts or two bolts directly). Design an algorithm for the problem that uses at most proportional to nlogn compares (probabilistically).

无法通过nuts之间/bolts之间比较来区分各自大小，只能通过一个nut和一个bolt的比较来区分大小。使用快排时，从nuts[]中选出一个nut作为比较基准来对bolts[]进行分块，记分块的结果为m。再以bolts[m]为比较基准对nuts[]进行分块，其结果同样为m。递归排序左右两块。当两个数组都排好序后，即完成了配对。

import java.util.Random;

class NB {
    int size;

    public NB(int size) {
        this.size = size;
    }
}

class Nut extends NB {
    public Nut(int size) {
        super(size);
    }
}

class Bolt extends NB {
    public Bolt(int size) {
        super(size);
    }
}

public class NutsAndBolts {
    private Nut[] nuts;
    private Bolt[] bolts;

    public NutsAndBolts(Nut[] nuts, Bolt[] bolts) {
        this.nuts = nuts;
        this.bolts = bolts;
        sort(0, nuts.length - 1);
    }

    private void sort(int left, int right) {
        if (left >= right) {
            return;
        }
        int random = new Random().nextInt(right - left + 1) + left;
        swap(nuts, left, random);
        for (int i = left; i <= right; i++) {
            if (bolts[i].size == nuts[left].size) {
                swap(bolts, left, i);
                break;
            }
        }
        int m = partition(bolts, nuts[left], left, right);
        partition(nuts, bolts[m], left, right);
        sort(left, m - 1);
        sort(m + 1, right);
    }

    // 加入base是因为题目规定同类型之间无法比较，只能不同类型间比较
    // base为待分块数组的相对应数组中的元素
    private int partition(NB[] a, NB base, int left, int right) {
        NB temp = a[left];
        while (left < right) {
            while (left < right && a[right].size > base.size) {
                right--;
            }
            a[left] = a[right];
            while (left < right && a[left].size <= base.size) {
                left++;
            }
            a[right] = a[left];
        }
        a[left] = temp;
        return left;
    }

    private void swap(NB[] a, int i, int j) {
        NB temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

Selection in two sorted arrays. Given two sorted arrays a*[] and b[], of sizes $n_1$ and $n_2$, respectively, design an algorithm to find the $k^{th}$ largest key. The order of growth of the worst case running time of your algorithm should be logn, where $n=n_1+n_2$.

• Version 1: $n_1=n_2$ and k=n/2
• Version 2: k=n/2
• Version 3: no restrictions

LeetCode原题：4. Median of Two Sorted Arrays (H)

public class SelectionInTwo {
    public static int findKth(int[] a, int[] b, int k) {
        return findKth(a, b, 0, a.length - 1, 0, b.length - 1, k);
    }

    private static int findKth(int[] a, int[] b, int as, int ae, int bs, int be, int k) {
        int aLen = ae - as + 1;
        int bLen = be - bs + 1;

        // 边界条件处理

        // 保持a为长度较小的数组
        if (aLen > bLen) {
            return findKth(b, a, bs, be, as, ae, k);
        }
        // a被删完后可直接找到第k大
        if (aLen == 0) {
            return b[k - 1];
        }
        // k==1为特殊情况
        if (k == 1) {
            return Math.min(a[as], b[bs]);
        }

        int p = Math.min(aLen, k / 2);
        int q = k - p;
        if (a[as + p - 1] < b[bs + q - 1]) {
            return findKth(a, b, as + p, ae, bs, be, k - p);
        } else if (a[as + p - 1] > b[bs + q - 1]) {
            return findKth(a, b, as, ae, bs + q, be, k - q);
        } else {
            return a[as + p - 1];
        }
    }
}

Decimal dominants. Given an array with n keys, design an algorithm to find all values that occur more than n/10 times. The expected running time of your algorithm should be linear.

在包含n个元素的数组中找出所有出现次数大于n/10的元素，要求复杂度为O(N)。

最简单的方法为hash，但是空间复杂度高达O(N)。

根据hint优化方法：如果将数组排好序，那么每个出现次数大于n/10的元素最多只可能为$a[(\frac{n}{10}+1)\ast i-1]$中的9个。针对这几个分隔节点上的元素去hash可以大大减少额外空间。寻找第K大可以使用quick-select方法。

import java.util.HashSet;
import java.util.Set;

public class DecimalDominants {
    private int[] a;
    private Set<Integer> possible;
    private int[] count;
    private final int MIN;

    public DecimalDominants(int[] a) {
        this.a = a;
        MIN = a.length / 10 + 1;
        possible = new HashSet<>();
        count = new int[9];
        run();
    }

    public void run() {
        for (int i = 1; i <= 9; i++) {
            int k = MIN * i;
            if (k > a.length) {
                break;
            }
            possible.add(findKth(k));
        }

        // possible.size()最大为9
        for (Integer p : possible) {
            int count = 0;
            for (int i = 0; i < a.length; i++) {
                if (a[i] == p) {
                    count++;
                    if (count == MIN) {
                        System.out.println(p);
                        break;
                    }
                }
            }
        }
    }

    private int findKth(int k) {
        int left = 0;
        int right = a.length - 1;
        while (left < right) {
            int m = partition(left, right);
            if (m < k - 1) {
                left = m + 1;
            } else if (m > k - 1) {
                right = m - 1;
            } else {
                return a[k - 1];
            }
        }
        return a[k - 1];
    }

    private int partition(int left, int right) {
        int temp = a[left];
        while (left < right) {
            while (left < right && a[right] > temp) {
                right--;
            }
            a[left] = a[right];
            while (left < right && a[left] <= temp) {
                left++;
            }
            a[right] = a[left];
        }
        a[left] = temp;
        return left;
    }
}

---

参考

啊h_a - 普林斯顿大学算法课：Nuts and bolts