空间换时间和时间换空间

算法有两个指标：运行时间、内存消耗。
考虑实际情况，可能会用“空间换时间”或者用“时间换空间”。
以数组排序为例。很明显，冒泡排序，通过新增一个中间变量，用空间换时间，执行速度快。而异或运算没有引入新的变量。

package com.asin.java.csdn;  
  
import java.util.Arrays;  
  
public class AlgorithmCompare {  
    public static void main(String[] args) {  
  
        int[] num = { 2, 5, 1, 7, 3, 8, 6, 9, 0 };  
  
        long start = System.nanoTime();  //纳秒  
  
        // sortThird(num); // 191999  
        bubbleSort(num);   //   5531  
  
        long end = System.nanoTime();  
  
        System.out.println(end - start);  
    }  
  
    /** 
     * 冒泡排序，空间换时间 
     */  
    public static void bubbleSort(int[] a) {  
        int n = a.length;  
        for (int i = 0; i < n - 1; i++) {  
            for (int j = 0; j < n - 1; j++) {  
                if (a[j] > a[j + 1]) {  
                    int temp = a[j];  
                    a[j] = a[j + 1];  
                    a[j + 1] = temp;  
                }  
            }  
        }  
    }  
  
    /** 
     * 异或运算，时间换空间 
     */  
    private static void sortThird(int[] num) {  
        for (int i = 1; i < num.length; i++) {  
            int j = i;  
            while (true) {  
                if (j > 0 && num[j] < num[j - 1]) {  
                    // change  
                    num[j] = num[j] ^ num[j - 1];  
                    num[j - 1] = num[j] ^ num[j - 1];  
                    num[j] = num[j] ^ num[j - 1];  
                    j--;  
                } else {  
                    break;  
                }  
            }  
        }  
        System.out.println("sortThird:" + Arrays.toString(num));  
    }  
}