Java数据结构与算法

基本知识
时间复杂度

评估算法优劣的核心指标是什么？

时间复杂度（流程决定）
额外空间复杂度（流程决定）
常数项时间（实现细节决定）

什么是时间复杂度？时间复杂度怎么估算？

常数时间的操作
确定算法流程的总操作数量与样本数量之间的表达式关系
只看表达式最高阶项的部分

何为常数时间的操作？

如果一个操作的执行时间不以具体样本量为转移，每次执行时间都是固定时间。称这样的操作为常数时间的操作。

常见的常数时间的操作

● 常见的算术运算（+、-、*、/、% 等）
● 常见的位运算（>>、>>>、<<、|、&、^等）
● 赋值、比较、自增、自减操作等
● 数组寻址操作

如何确定算法流程的时间复杂度？

当完成了表达式的建立，只要把最高阶项留下即可。低阶项都去掉，高阶项的系数也去掉。
记为：O(忽略掉系数的高阶项)

时间复杂度的意义

时间复杂度的意义在于：
当我们要处理的样本量很大很大时，我们会发现低阶项是什么不是最重要的；每一项的系数是什么，不是最重要的。真正重要的就是最高阶项是什么。
这就是时间复杂度的意义，它是衡量算法流程的复杂程度的一种指标，该指标只与数据量有关，与过程之外的优化无关。

常见的时间复杂度

排名从好到差：
O(1)
O(logN)
O(N)
O(N*logN)
O(N^2) O(N^3) … O(N^K)
O(2^N) O(3^N) … O(K^N)
O(N!)

额外空间复杂度
你要实现一个算法流程，在实现算法流程的过程中，你需要开辟一些空间来支持你的算法流程。
作为输入参数的空间，不算额外空间。作为输出结果的空间，也不算额外空间。
因为这些都是必要的、和现实目标有关的。所以都不算。
但除此之外，你的流程如果还需要开辟空间才能让你的流程继续下去。这部分空间就是额外空间。
如果你的流程只需要开辟有限几个变量，额外空间复杂度就是O(1)。

对数器
认识对数器
【Java算法】06_对数器

认识对数器

1、你想要测的方法a
2、实现复杂度不好但是容易实现的方法b
3、实现一个随机样本产生器
4、把方法a和方法b跑相同的随机样本，看看得到的结果是否一样
5、如果有一个随机样本使得比对结果不一致，打印样本进行人工干预，改对方法a和方法b
6、当样本数量很多时比对测试依然正确，可以确定方法a已经正确。

排序算法
选择排序

基本思想：每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素为止。
算法实现：每一趟通过不断地比较交换来使得首元素为当前最小，交换是一个比较耗时间的操作。我们可以通过设置一个值来记录较小元素的下标，循环结束后存储的当前最小元素的下标，这时在进行交换就可以了。

public class SelectionSort {

public static void selectionSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    for (int i = 0; i < arr.length; i++) {
        // 最小值在哪个位置上  i～n-1
        int minIndex = i;
        for (int j = i; i < arr.length; j++) { // i ~ N-1 上找最小值的下标
            minIndex = arr[j] < arr[minIndex] ? j : minIndex;
        }
        swap(arr, i, minIndex);
    }
}

// 交换
public static void swap(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

}

冒泡排序
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳)的气泡最终会上浮到顶端一样，故名“冒泡排序”。

原理
1、比较相邻的元素。如果第一个比第二个大，就交换他们两个
2、对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3、针对所有的元素重复以上的步骤，除了最后一个。
4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码实现
// 冒泡排序
public class BubbleSort {
public static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}

    for (int e = arr.length - 1; e > 0; e--) { // 0 ~ e
        for (int i = 0; i < e; i++) {
            if (arr[i] > arr[i + 1]) {
                swap(arr, i, i + 1);
            }
        }
    }
}

// 交换arr的i和j位置上的值
public static void swap(int[] arr, int i, int j) {
    arr[i] = arr[i] ^ arr[j];
    arr[j] = arr[i] ^ arr[j];
    arr[i] = arr[i] ^ arr[j];
}

}
插入排序

过程：
想让arr[0~0]上有序，这个范围只有一个数，当然是有序的。
想让arr[0~1]上有序，所以从arr[1]开始往前看，如果arr[1]<arr[0]，就交换。否则什么也不做。
…
想让arr[0~i]上有序，所以从arr[i]开始往前看，arr[i]这个数不停向左移动，一直移动到左边的数字不再比自己大，停止移动。
最后一步，想让arr[0~N-1]上有序， arr[N-1]这个数不停向左移动，一直移动到左边的数字不再比自己大，停止移动。

// 插入排序
public class InsertionSort {

public static void insertionSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }

    for (int i = 1; i < arr.length; i++) {
        // arr[i]往前看，一直交换到合适的位置停止
        for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
            swap(arr, j, j + 1);
        }
    }
}

public static void swap(int[] arr, int i, int j) {
    arr[i] = arr[i] ^ arr[j];
    arr[j] = arr[i] ^ arr[j];
    arr[i] = arr[i] ^ arr[j];
}

}
归并排序
1）整体是递归，左边排好序+右边排好序+merge让整体有序
2）让其整体有序的过程里用了排外序方法
3）利用master公式来求解时间复杂度
4）当然可以用非递归实现
时间复杂度
T(N) = 2T(N/2) + O(N^1)
根据master可知时间复杂度为O(NlogN)
merge过程需要辅助数组，所以额外空间复杂度为O(N)
归并排序的实质是把比较行为变成了有序信息并传递，比O(N^2)的排序快
public class MergeSort {

public static void merge(int[] arr, int L, int M, int R) {
	int[] help = new int[R - L + 1];
	int i = 0;
	int p1 = L;
	int p2 = M + 1;
	while (p1 <= M && p2 <= R) {
		help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
	}
	while (p1 <= M) {
		help[i++] = arr[p1++];
	}
	while (p2 <= R) {
		help[i++] = arr[p2++];
	}
	for (i = 0; i < help.length; i++) {
		arr[L + i] = help[i];
	}
}

// 递归方法实现
public static void mergeSort1(int[] arr) {
	if (arr == null || arr.length < 2) {
		return;
	}
	process(arr, 0, arr.length - 1);
}

public static void process(int[] arr, int L, int R) {
	if (L == R) {
		return;
	}
	int mid = L + ((R - L) >> 1);
	process(arr, L, mid);
	process(arr, mid + 1, R);
	merge(arr, L, mid, R);
}

}
快速排序
在arr[L…R]范围上，进行快速排序的过程：
1）在这个范围上，随机选一个数记为num，
1）用num对该范围做partition，< num的数在左部分，== num的数中间，>num的数在右部分。假设== num的数所在范围是[a,b]
2）对arr[L…a-1]进行快速排序(递归)
3）对arr[b+1…R]进行快速排序(递归)因为每一次partition都会搞定一批数的位置且不会再变动，所以排序能完成
时间复杂度分析
1）通过分析知道，划分值越靠近中间，性能越好；越靠近两边，性能越差
2）随机选一个数进行划分的目的就是让好情况和差情况都变成概率事件
3）把每一种情况都列出来，会有每种情况下的时间复杂度，但概率都是1/N
4）那么所有情况都考虑，时间复杂度就是这种概率模型下的长期期望！时间复杂度O(N*logN)，额外空间复杂度O(logN)都是这么来的。
public class Code03_PartitionAndQuickSort {

public static void swap(int[] arr, int i, int j) {
	int tmp = arr[i];
	arr[i] = arr[j];
	arr[j] = tmp;
}

public static int[] netherlandsFlag(int[] arr, int L, int R) {
	if (L > R) {
		return new int[] { -1, -1 };
	}
	if (L == R) {
		return new int[] { L, R };
	}
	int less = L - 1;
	int more = R;
	int index = L;
	while (index < more) {
		if (arr[index] == arr[R]) {
			index++;
		} else if (arr[index] < arr[R]) {
			swap(arr, index++, ++less);
		} else {
			swap(arr, index, --more);
		}
	}
	swap(arr, more, R);
	return new int[] { less + 1, more };
}

public static void quickSort(int[] arr) {
	if (arr == null || arr.length < 2) {
		return;
	}
	process3(arr, 0, arr.length - 1);
}

public static void process(int[] arr, int L, int R) {
	if (L >= R) {
		return;
	}
	swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
	int[] equalArea = netherlandsFlag(arr, L, R);
	process(arr, L, equalArea[0] - 1);
	process(arr, equalArea[1] + 1, R);
}

}
堆排序
1）堆结构就是用数组实现的完全二叉树结构2）
完全二叉树中如果每棵子树的最大值都在顶部就是大根堆
3）完全二叉树中如果每棵子树的最小值都在顶部就是小根堆
4）堆结构的heapInsert与heapify操作
5）堆结构的增大和减少
6）优先级队列结构，就是堆结构
语言提供的堆结构 vs 手写的堆结构
取决于，你有没有动态改信息的需求！
语言提供的堆结构，如果你动态改数据，不保证依然有序
手写堆结构，因为增加了对象的位置表，所以能够满足动态改信息的需求
大根堆

小根堆

从上往下建堆 O(logN)

从下往上建堆 O(N)

从下往上建堆比从上往下建堆要快。

桶排序
计数排序
基数排序

比较器
1)比较器的实质就是重载比较运算符
2)比较器可以很好的应用在特殊标准的排序上
3)比较器可以很好的应用在根据特殊标准排序的结构上
4)写代码变得异常容易，还用于范型编程
同一规定
即如下方法：
@Override
public int compare(T o1, T o2)
;返回负数的情况，就是o1比o2优先的情况
返回正数的情况，就是o2比o1优先的情况
返回0的情况，就是o1与o2同样优先的情况

排序算法总结
时间复杂度 额外空间复杂度 稳定性
选择排序 O(N^2) O(1) 无
冒泡排序 O(N^2) O(1) 有
插入排序 O(N^2) O(1) 有
归并排序 O(NlogN) O(N) 有
随机快排 O(NlogN) O(logN) 无
堆排序 O(N*logN) O(1) 无

计数排序 O(N) O(M) 有
基数排序 O(N) O(N) 有

1）不基于比较的排序，对样本数据有严格要求，不易改写
2）基于比较的排序，只要规定好两个样本怎么比大小就可以直接复用
3）基于比较的排序，时间复杂度的极限是O(NlogN)
4）时间复杂度O(NlogN)、额外空间复杂度低于O(N)、且稳定的基于比较的排序是不存在的。
5）为了绝对的速度选快排、为了省空间选堆排、为了稳定性选归并

常见的坑
1）归并排序的额外空间复杂度可以变成O(1)，“归并排序 内部缓存法”，但是将变得不再稳定。
2）“原地归并排序" 是垃圾贴，会让时间复杂度变成O(N^2)
3）快速排序稳定性改进，“01 stable sort”，但是会对样本数据要求更多。

二分查找

位运算
异或运算
异或运算：相同为0，不同为1
能长时间记住的概率接近0%
所以，异或运算就记成无进位相加！
异或运算的性质
1)0^N == N N^N == 0
2)异或运算满足交换律和结合率

如何不用额外变量交换两个数

// 交换i和j的值
public static void swap(int i, int j) {
	i = i ^ j;
	j = i ^ j;
	i = i ^ j;
}

链表

单向链表节点结构
public class Node {
public int value;
public Node next;
public Node(int data) {
value = data;
}
}

双向链表节点结构

public class DoubleNode {
public int value;
public DoubleNode last;
public DoubleNode next;

public DoubleNode(int dat