java算法题收集

1. 10亿个数字里里面找最小的10个

import java.util.Random;

public class Test1 {

    static Random random = new Random();

    public static void main(String[] args) {
        /**第一个元素0不参与，只是用于占位置,这样的话，只要array[k]>array[2k] && array[k]>array[2k+1]那就是最大堆了，
         * 此外，这里暂时用20个数代替1亿个
         */
        int[] array = new int[100000000];
        for (int i = 0; i < 100000000; i++) {
            int tempNum = random.nextInt(Integer.MAX_VALUE);
            array[i] = tempNum;
        }

        long st = System.currentTimeMillis();
        //建立建立节点个数为10的最大堆
        for (int i = 10 / 2; i >= 1; i--) {
            adjustHeap(array, i, 10);
        }
        for (int i = 11; i < array.length; i++) {
            //如果这个元素小于堆顶，和堆顶交换，然后重新调整堆
            if (array[i] < array[1]) {
                swap(array, i, 1);
                adjustHeap(array, 1, 10);
            }
        }

        long et = System.currentTimeMillis();
        System.out.println("用时:" + (et - st) + "ms");
        System.out.println("最小的10个数字为：");
        for (int i = 1; i <= 10; i++) {
            System.out.print(array[i] + " ");
        }
    }

    /**
     * 交换
     */
    private static void swap(int[] array, int i, int j) {
        int tem = array[i];
        array[i] = array[j];
        array[j] = tem;
    }

    /**
     * 在以array[head]为根的左右子树是最大堆的前提下把以array[head]为根的树调整为最大堆
     */
    static void adjustHeap(int[] array, int head, int tail) {
        int root = array[head];
        int i = 2 * head;
        while (i <= tail) {
            int max = array[i];
            if (i + 1 <= tail) {
                if (array[i + 1] > array[i]) {
                    max = array[i + 1];
                    i++;
                }
            }
            if (root > max) {
                break;
            } else {
                array[i / 2] = array[i];
            }
            i *= 2;
        }
        array[i / 2] = root;
    }
}

2. 有1亿个数字，其中有2个是重复的，快速找到它，时间和空间要最优

public class Test1 {

    public static void main(String[] args) {
        //1亿长度
        int[] arr = new int[100000000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }
        arr[99999999] = 2020;

        long st = System.currentTimeMillis();

        int min = arr[0];
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        byte[] bucket = new byte[(max - min) / 8 + 1];
        for (int i = 0; i < arr.length; i++) {
            int num = arr[i];
            int j = (num - min) / 8;
            int k = (num - min) % 8;
            if (((bucket[j] >> k) & 1) > 0) {
                //重复了
                System.out.println("Number of repeats：" + num);
                break;
            } else {
                bucket[j] |= (1 << k);
            }
        }
        long et = System.currentTimeMillis();
        System.out.println("用时:" + (et - st) + "ms");
    }

}

3. 字符串反转

public class Test1 {

    public static void main(String[] args) {
        System.out.println(reverse("hello java"));
    }

    public static String reverse(String str) {
        char[] newStr = new char[str.length()];

        //循环字符串长度的１/2.
        for (int i = 0; i < str.length() / 2; i++) {
            newStr[i] = str.charAt(str.length() - i - 1);
            newStr[str.length() - i - 1] = str.charAt(i);
        }
        return new String(newStr);
    }

}