Interview Questions: Elementary Sorts

Elementary Sorts

Intersection of two sets. Given two arrays ?[] and ?[], each containing n distinct 2D points in the plane, design a subquadratic algorithm to count the number of points that are contained both in array ?[] and array ?[].

求两个坐标点集合的交集。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Intersection {
    public Node[] findIntersection(Node[] a, Node[] b) {
        int i = 0;
        int j = 0;
        List<Node> temp = new ArrayList<>();
        Arrays.sort(a);
        Arrays.sort(b);
        while (i < a.length && j < b.length) {
            if (a[i].compareTo(a[j]) < 0) {
                i++;
            } else if (a[i].compareTo(a[j]) > 0) {
                j++;
            } else {
                temp.add(a[i]);
                i++;
                j++;
            }
        }

        Node[] res = new Node[temp.size()];
        for (int k = 0; k < temp.size(); k++) {
            res[k] = temp.get(k);
        }
        return res;
    }

    private class Node implements Comparable<Node>{
        private int x;
        private int y;

        public Node(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public boolean equals(Object obj) {
            Node that = (Node) obj;
            if (this.x == that.x && this.y == that.y) {
                return true;
            }
            return false;
        }

        @Override
        public int compareTo(Node o) {
            if (this.x < o.x) {
                return -1;
            } else if (this.x > o.x) {
                return 1;
            } else if (this.y < o.y) {
                return -1;
            } else if (this.y > o.y) {
                return 1;
            } else {
                return 0;
            }
        }
    }
}

Permutation. Given two integer arrays of size n, design a subquadratic algorithm to determine whether one is a permutation of the other. That is, do they contain exactly the same entries but, possibly, in a different order.

排序后判断是否为相同数组。

import java.util.Arrays;

public class Permutation {
    public boolean judge(int[] a, int[] b) {
        shellSort(a);
        shellSort(b);
        return Arrays.equals(a, b);
    }

    private void shellSort(int[] a) {
        int n = a.length;
        int h = 1;
        while (h < n / 3) {
            h = h * 3 + 1;
        }
        while (h >= 1) {
            for (int i = h; i < n; i++) {
                int j = i;
                int temp = a[i];
                while (j >= h && temp < a[j - h]) {
                    a[j] = a[j - h];
                    j -= h;
                }
                a[j] = temp;
            }
            h /= 3;
        }
    }
}

Dutch national flag. Given an array of n buckets, each containing a red, white, or blue pebble, sort them by color. The allowed operations are:

• swap(i, j): swap the pebble in bucket ii with the pebble in bucket j.
• color(i): determine the color of the pebble in bucket i.

The performance requirements are as follows:

• At most n calls to color().
• At most n calls to swap().
• Constant extra space.

将数组重新排序为三个从大到小的区间。把0全部换到数组前半段，把2全部换到数组后半段，自然就排好了序。

public class Dutch {
    public void partition(int[] a) {
        int left = 0;
        int right = a.length - 1;
        int i = 0;
        while (i <= right) {
            if (a[i] == 0) {
                swap(a, left++, i++);	// 调换后i处只可能为0或1，所以可以i++
            } else if (a[i] == 2) {
                swap(a, right--, i);	// 调换后i处可能为0或1或2，需要在下个循环再次对i进行判断
            } else {
                i++;
            }
        }
    }

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