算法小技巧

1、巧用数组下标

n个无序的int整型数组arr，并且这些整数的取值范围都在0-20之间，要你在 O(n) 的时间复杂度中把这 n 个数按照从小到大的顺序打印出来

 

 public static void main(String[] args) {
    	int[] arr = new int[] {13, 13, 5, 7, 8, 17, 14, 7, 9, 13, 19, 14, 4, 5, 7, 0, 6, 11, 7, 9, 16};
    	/*Random random = new Random();
    	for (int i = 0; i < arr.length; i++) {
           arr[i] = random.nextInt(20);
        }*/
    	f(arr);
	}
    
    public static void f(int arr[]) {

        int[] temp = new int[21];
        for (int i = 0; i < arr.length; i++) {
            temp[arr[i]]++;
        }
        for (int i = 0; i < temp.length; i++) {
        	 System.out.println(i+":"+temp[i]);
        }
        //顺序打印
        for (int i = 0; i < 21; i++) {
            for (int j = 0; j < temp[i]; j++) {
                System.out.println(i);
            }
        }
    }

 

2、巧用位移运算

有时候我们在进行除数或乘数运算的时候，例如n / 2，n / 4, n / 8这些运算的时候，我们就可以用移位的方法来运算了，这样会快很多。

例如:

n / 2 等价于 n >> 1

n / 4 等价于 n >> 2

n / 8 等价于 n >> 3；

 

n*2 等价于n<<1

n*4 等价于n<<2

n*8 等价于n<<3

还有一些 &(与)、|(或)的运算，也可以加快运算的速度。例如判断一个数是否是奇数，你可能会这样做

if(n % 2 == 1){
 dosomething();
}

不过我们用与或运算的话会快很多。例如判断是否是奇数，我们就可以把n和1相与了，如果结果为1，则是奇数，否则就不会。即

if(n & 1 == 1){
 dosomething();
)

3、对于递归可以考虑将状态进行保存

当我们使用递归来解决一个问题的时候，容易产生重复去算同一个子问题，这个时候我们要考虑状态保存以防止重复计算。

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法？

最简单的解答方案：

 public int f(int n) {
       if (n <= 2) {
           return n;
       } else {
           return f(n - 1) + f(n - 2);
       }
   }

不过对于可以使用递归解决的问题，我们一定要考虑是否有很多重复计算。显然对于 f(n) = f(n-1) + f(n-2) 的递归，是有很多重复计算的，这个时候我们要考虑状态保存

优化后：

public static int f(int n) {
    	int[] arr = new int[1000]; 
    	if (n <= 2) {
			return n;
		} else {
			if (arr[n] != 0) {// 已经计算过，直接返回
				return arr[n];
			} else {
				arr[n] = f(n-1) + f(n -2);
				return arr[n]; 
			}
		}
    }

3、使用bitSet对没有重复的数字进行排序，例如统计40亿个数据中没有出现的数据，将40亿个不同数据进行排序等。

public static void sortArray() {
		int[] array = new int[] { 423, 700, 9999, 9999, 9999, 9999, 9999, 2323, 356, 6400, 1, 2, 3, 2, 2, 2, 2 };
		BitSet bitSet = new BitSet(2 << 10);
		// 虽然可以自动扩容，但尽量在构造时指定估算大小，
		// 我们要看一下数组中的最大值，然后指定大致的容量，默认为64
		System.out.println("BitSet size: " + bitSet.size());

		for (int i = 0; i < array.length; i++) {
			bitSet.set(array[i]);
		}
		// 剔除重复数字后的元素个数
		int bitLen = bitSet.cardinality();
		System.out.println("要排序的数组容量：" + array.length);
		System.out.println("剔除重复数字后的元素个数：" + bitLen);

		// 进行排序，即把bit为true的元素复制到另一个数组
		int[] orderedArray = new int[bitLen];
		int k = 0;
		for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
			orderedArray[k++] = i;
		}

		System.out.println("After ordering: ");
		for (int i = 0; i < bitLen; i++) {
			System.out.print(orderedArray[i] + "\t");
		}
		System.out.println("\n通过迭代器获取排序后的元素：");
		// 或直接迭代BitSet中bit为true的元素
		for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
			System.out.print(i + "\t");
		}
		System.out.println("\n---------------------------");
	}