算法<初级> - 第二章 队列、栈、哈希表、链表相关问题（完结）
算法<初级> - 第二章 队列、栈、哈希表相关问题
题目一 用数组实现大小固定的队列和栈（一面题）
数组实现大小固定栈
/***
* size是对头索引（initSize是固定大小） 也是当前栈大小
* size=下个进队index
* size-1=下个出队index
* size==initSize时队满 判满
* size==0时队空 判空
***/
public static class ArrayStack {
private Integer[] arr;
private Integer size; /
public ArrayStack(int initSize) {
if (initSize < 0) {
throw new IllegalArgumentException("The init size is less than 0");
}
arr = new Integer[initSize];
size = 0;
}
public Integer peek() { //返回栈头元素
if (size == 0) {
return null;
}
return arr[size - 1];
}
public void push(int obj) {
if (size == arr.length) {
throw new ArrayIndexOutOfBoundsException("The queue is full");
}
arr[size++] = obj;
}
public Integer pop() {
if (size == 0) {
throw new ArrayIndexOutOfBoundsException("The queue is empty");
}
return arr[--size];
}
}
数组实现大小固定队列
/***
* size当前队列大小；用size关联first/last更加方便
* last队尾
* first队头
* 循环队列：
* first = first == arr.length - 1 ? 0 : first + 1;
* last = last == arr.length - 1 ? 0 : last + 1;
***/
public static class ArrayQueue {
private Integer[] arr;
private Integer size;
private Integer first;
private Integer last;
public ArrayQueue(int initSize) {
if (initSize < 0) {
throw new IllegalArgumentException("The init size is less than 0");
}
arr = new Integer[initSize];
size = 0;
first = 0;
last = 0;
}
public Integer peek() { //查看队头元素
if (size == 0) {
return null;
}
return arr[first];
}
public void push(int obj) { //进队
if (size == arr.length) {
throw new ArrayIndexOutOfBoundsException("The queue is full");
}
size++;
arr[last] = obj;
last = last == arr.length - 1 ? 0 : last + 1; //循环队列
}
public Integer poll() { //出队弹出
if (size == 0) {
throw new ArrayIndexOutOfBoundsException("The queue is empty");
}
size--;
int tmp = first;
first = first == arr.length - 1 ? 0 : first + 1;
return arr[tmp];
}
}
题目二：实现一个特殊的栈
-
题目表述：实现一个特殊的栈，在实现栈的基本功能上再实现返回栈最小值的操作。
【要求】：
1. pop、push、geiMin操作的时间复杂度O(1)
2. 设计的栈类型可以使用现成的栈结构 -
思想：
- 基本栈的结构 - 双向链表/动态数组
- 思路一：构造两个栈，一个data栈，一个min栈。data栈压栈入栈元素，同时min栈压栈最小元素（每来一个元素与栈顶元素比较，谁小压谁）。出栈则两个栈同时弹出
- data：||32415
- min：||32211
- 思路二：构造两个栈，data / min栈。data栈压入栈元素，min栈顶元素比较，小则同时压入min栈，否则不压栈。出栈则比较，data栈出栈元素=min栈顶元素时，min栈出栈。
- data：||32415
- min：||321
思路一
- 算法实现（Java）
public static class MyStack1 { //思路一
private Stack<Integer> stackData;
private Stack<Integer> stackMin;
public MyStack1() {
this.stackData = new Stack<Integer>();
this.stackMin = new Stack<Integer>();
}
public void push(int newNum) {
if (this.stackMin.isEmpty()) {
this.stackMin.push(newNum);
} else if (newNum <= this.getmin()) {
this.stackMin.push(newNum);
}
this.stackData.push(newNum);
}
public int pop() {
if (this.stackData.isEmpty()) {
throw new RuntimeException("Your stack is empty.");
}
int value = this.stackData.pop();
if (value == this.getmin()) {
this.stackMin.pop();
}
return value;
}
public int getmin() {
if (this.stackMin.isEmpty()) {
throw new RuntimeException("Your stack is empty.");
}
return this.stackMin.peek();
}
}
思路二
- 算法实现（Java）
public static class MyStack2 { //思路二
private Stack<Integer> stackData;
private Stack<Integer> stackMin;
public MyStack2() {
this.stackData = new Stack<Integer>();
this.stackMin = new Stack<Integer>();
}
public void push(int newNum) {
if (this.stackMin.isEmpty()) {
this.stackMin.push(newNum);
} else if (newNum < this.getmin()) {
this.stackMin.push(newNum);
} else {
int newMin = this.stackMin.peek();
this.stackMin.push(newMin);
}
this.stackData.push(newNum);
}
public int pop() {
if (this.stackData.isEmpty()) {
throw new RuntimeException("Your stack is empty.");
}
this.stackMin.pop();
return this.stackData.pop();
}
public int getmin() {
if (this.stackMin.isEmpty()) {
throw new RuntimeException("Your stack is empty.");
}
return this.stackMin.peek();
}
}
题目三：队列实现栈 / 栈实现队列（灵活应用）
队列实现栈
- 思路
- 用两个队列实现栈
- 序列先全进第一个队列，进行以下操作：
- 保留最后一个数其他元素全部出队列，进入第二个队列
- 把第一个队列的值输出（即让最后进来的最先出去）
- 之后第二个队列同样操作进入第一个队列，把最后一个元素输出
- 演示
- 54321 空 —> 5 4321 输出5
- 空 4321 —> 321 4 输出4
+算法实现（Java）
public static class TwoQueuesStack {
private Queue<Integer> queue;
private Queue<Integer> help;
public TwoQueuesStack() {
queue = new LinkedList<Integer>();
help = new LinkedList<Integer>();
}
public void push(int pushInt) {
queue.add(pushInt);
}
public int peek() { //得到栈顶元素
if (queue.isEmpty()) {
throw new RuntimeException("Stack is empty!");
}
while (queue.size() != 1) {
help.add(queue.poll());
}
int res = queue.poll(); //res为最后一个入队元素
help.add(res);
swap(); //两个栈引用交换一下
return res;
}
public int pop() {
if (queue.isEmpty()) {
throw new RuntimeException("Stack is empty!");
}
while (queue.size() != 1) {
help.add(queue.poll());
}
int res = queue.poll();
swap();
return res;
}
private void swap() {
Queue<Integer> tmp = help;
help = queue;
queue = tmp;
}
}
栈实现队列
- 思路
- 用两个栈实现队列：第一个栈专做push，第二个栈专做pop
- 直接入第一个栈，全部倒入第二个栈，第二个栈再全部出栈，即可实现先进先出
- 一栈倒二栈时机：
- 当pop栈中非空时，push栈不能倒
- pop栈为空时push倒，倒必须一次性倒完
- 只要满足上述两个条件，无论倒数操作发生在什么时候，都一定对
- 算法实现（Java）
public static class TwoStacksQueue {
private Stack<Integer> stackPush;
private Stack<Integer> stackPop;
public TwoStacksQueue() {
stackPush = new Stack<Integer>();
stackPop = new Stack<Integer>();
}
public void push(int pushInt) {
stackPush.push(pushInt);
}
public int poll() {
if (stackPop.empty() && stackPush.empty()) {
throw new RuntimeException("Queue is empty!");
} else if (stackPop.empty()) { //倒数操作
while (!stackPush.empty()) {
stackPop.push(stackPush.pop());
}
}
return stackPop.pop();
}
public int peek() {
if (stackPop.empty() && stackPush.empty()) {
throw new RuntimeException("Queue is empty!");
} else if (stackPop.empty()) {
while (!stackPush.empty()) {
stackPop.push(stackPush.pop());
}
}
return stackPop.peek();
}
}
题目四：猫狗队列
- 题目表述：有如下猫类狗类，实现一个猫狗队列结构
- add方法将cat / dog类实例入队
- pollAll方法将所有实例出队
- pollDog方法将所有狗实例出队
- pollCat方法同理
- isEmpty方法判断是否还有猫狗实例
- isDogEmpty方法同理
- isCatEmpty方法同理
- 猫狗类型：
public static class Pet {
private String type;
public Pet(String type) {
this.type = type;
}
public String getPetType() {
return this.type;
}
}
public static class Dog extends Pet {
public Dog() {
super("dog");
}
}
public static class Cat extends Pet {
public Cat() {
super("cat");
}
}
-
思路
- 猫狗各一个队列，队列中用封装类PetEnterQueue，封装了一个pet类和一个count标志。
- all系列函数则根据count标志的大小来决定同一队头谁先出
-
算法实现（Java）
public static class PetEnterQueue { //为了不修改底层类，封装进一个新类
private Pet pet;
private long count; //标记自己是几号，衡量猫狗谁先出
public PetEnterQueue(Pet pet, long count) {
this.pet = pet;
this.count = count;
}
public Pet getPet() {
return this.pet;
}
public long getCount() {
return this.count;
}
public String getEnterPetType() {
return this.pet.getPetType();
}
}
public static class DogCatQueue {
private Queue<PetEnterQueue> dogQ;
private Queue<PetEnterQueue> catQ;
private long count;
public DogCatQueue() {
this.dogQ = new LinkedList<PetEnterQueue>();
this.catQ = new LinkedList<PetEnterQueue>();
this.count = 0;
}
public void add(Pet pet) {
if (pet.getPetType().equals("dog")) {
this.dogQ.add(new PetEnterQueue(pet, this.count++));
} else if (pet.getPetType().equals("cat")) {
this.catQ.add(new PetEnterQueue(pet, this.count++));
} else {
throw new RuntimeException("err, not dog or cat");
}
}
public Pet pollAll() {
if (!this.dogQ.isEmpty() && !this.catQ.isEmpty()) {
if (this.dogQ.peek().getCount() < this.catQ.peek().getCount()) {
return this.dogQ.poll().getPet();
} else {
return this.catQ.poll().getPet();
}
} else if (!this.dogQ.isEmpty()) {
return this.dogQ.poll().getPet();
} else if (!this.catQ.isEmpty()) {
return this.catQ.poll().getPet();
} else {
throw new RuntimeException("err, queue is empty!");
}
}
public Dog pollDog() {
if (!this.isDogQueueEmpty()) {
return (Dog) this.dogQ.poll().getPet();
} else {
throw new RuntimeException("Dog queue is empty!");
}
}
public Cat pollCat() {
if (!this.isCatQueueEmpty()) {
return (Cat) this.catQ.poll().getPet();
} else
throw new RuntimeException("Cat queue is empty!");
}
public boolean isEmpty() {
return this.dogQ.isEmpty() && this.catQ.isEmpty();
}
public boolean isDogQueueEmpty() {
return this.dogQ.isEmpty();
}
public boolean isCatQueueEmpty() {
return this.catQ.isEmpty();
}
}
哈希表
- 增删改查默认时间复杂度O(1)，但是常数项比较大 - 因为哈希函数在算值的时候代价比较大
哈希函数hashmap
- 性质
- 输入域无限，输出域有限
- 哈希函数不是随机函数，相同输入一定得到相同输出 same input same out
- 哈希碰撞：不同的输入也可能得到相同的输出 diff input same out
- 哈希函数的离散性：虽然性质①，但是不同的输入在输出域上得到的返回值会均匀分布（最重要性质）—> 用来打乱输入规律
哈希表/散列表
- 经典实现结构：由输出域组成的一组数组，每个值对应一组输入值链表。输入值根据哈希函数得到输出域上对应的某值，然后挂载在数组值的链表上。
- 哈希表扩容
- 当挂载链表太长时，可以选择哈希表扩容，成倍扩容，时间复杂度可以做到O(1)
- 可以离线扩容，扩容频率也不频繁
- Java哈希表实现结构：输出域仍然是一组数组，每个值后挂载的是一棵红黑树treemap
- hashset & hashmap
- 实际上都是哈希表，前者add(key)，后者put(key,value)，value实际上就是key多出的一个伴随数据，并不影响哈希表结构
题目五：设计RandomPool结构
-
题目表述：设计一种结构，在该结构中有如下三个功能，要求时间复杂度O(1)：
- insert(key)：将某个key加入到该结构，做到不重复加入
- delete(key)：将原本在结构中的某个key移除
- getRandom()：等概率随机返回结构中任何一个key
-
思路
- 直接用哈希表就可以完成，难点的是（有delete情况下的getRandom）
- 设置两张哈希表，第一个哈希表key是加入的值，value是第几个加入的；第二个哈希表key是第几个加入的，value是加入的值
- 设置一个index变量，int index=0，每加入一个key，index++
- insert和delete可以直接在第一个哈希表中完成，第二个哈希表也对应做出相同操作
- getRandom可以直接随机函数生成一个随机数，但是问题是delete可能会使（第几个加入的）值变成不连续的，导致无法使用随机函数
- 解决：
- 每当删除一个key时，先让inedx--，再让index位置上的key（即最后加入的key），覆盖掉要删除的key，原要删除的value不变，把最后加入的key/value行删除。
- 这样即可让value是一个连续的值，可以直接用随机函数随机get
-
算法实现（Java）
public static class Pool<K> { //K模板
private HashMap<K, Integer> keyIndexMap;
private HashMap<Integer, K> indexKeyMap;
private int size;
public Pool() {
this.keyIndexMap = new HashMap<K, Integer>();
this.indexKeyMap = new HashMap<Integer, K>();
this.size = 0;
}
public void insert(K key) {
if (!this.keyIndexMap.containsKey(key)) {
this.keyIndexMap.put(key, this.size);
this.indexKeyMap.put(this.size++, key);
}
}
public void delete(K key) {
if (this.keyIndexMap.containsKey(key)) {
int deleteIndex = this.keyIndexMap.get(key);
int lastIndex = --this.size;
K lastKey = this.indexKeyMap.get(lastIndex);
this.keyIndexMap.put(lastKey, deleteIndex);
this.indexKeyMap.put(deleteIndex, lastKey);
this.keyIndexMap.remove(key);
this.indexKeyMap.remove(lastIndex);
}
}
public K getRandom() {
if (this.size == 0) {
return null;
}
int randomIndex = (int) (Math.random() * this.size);
return this.indexKeyMap.get(randomIndex);
}
}
题目六：转圈打印矩阵（矩阵打印题）
-
题目表述：给定一个整型矩阵matrix，请按照转圈的方式打印它，要求空间复杂度O(1)
例如：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
打印结果为：1，2，3，4，8，12，16，15，14，13，9，5，6，7，11，10 -
对于矩阵/数组打印题，应该往一种宏观调度的思想，而不要着眼于索引位置的变换。
-
思路：
-
划定两个点，圈的左上角和右下角，然后一圈一圈的打印输出
-
打印圈圈printEage()：左上(row1,col1) / 右下(row2,col2) / 目前点(curRow,curCol)
- 初始化目前点为左上，打印目前点元素；
- 当curRow<row2时，打印目前点位置元素，curRow++；
- curRol = row2后，当curCol<col2时，打印目前点位置元素，curCol++；
- 当目前点到右下点后继续
- 当curRow>row1时，打印目前点位置元素，curRow--；
- curRow=row1后，当curCol>col1时，打印目前点位置元素，curCol--；
-
主函数Matrixprint()：
- while()打印外圈，打印完后row1++，col1++，row2--，col2--；
- 跳出条件：左上点<=右下点
-
-
算法实现（Java）
public static void spiralOrderPrint(int[][] matrix) {
int tR = 0;
int tC = 0;
int dR = matrix.length - 1;
int dC = matrix[0].length - 1;
while (tR <= dR && tC <= dC) {
printEdge(matrix, tR++, tC++, dR--, dC--);
}
}
public static void printEdge(int[][] m, int tR, int tC, int dR, int dC) {
if (tR == dR) { // 只有一行的时候
for (int i = tC; i <= dC; i++) {
System.out.print(m[tR][i] + " ");
}
} else if (tC == dC) { // 只有一列的时候
for (int i = tR; i <= dR; i++) {
System.out.print(m[i][tC] + " ");
}
} else { // n*m矩阵的时候
int curC = tC;
int curR = tR;
while (curC != dC) {
System.out.print(m[tR][curC] + " ");
curC++;
}
while (curR != dR) {
System.out.print(m[curR][dC] + " ");
curR++;
}
while (curC != tC) {
System.out.print(m[dR][curC] + " ");
curC--;
}
while (curR != tR) {
System.out.print(m[curR][tC] + " ");
curR--;
}
}
}
题目七：之字形打印矩阵（矩阵打印题）
-
题目表述
- 给定一个矩阵matrix按照之字形打印矩阵，要求空间复杂度O(1)
例如：
1 2 3 4
5 6 7 8
9 10 11 12
之字形打印结果：1，2 ，5 ，9 ，6 ，3，4，7，10，11，8，12
- 给定一个矩阵matrix按照之字形打印矩阵，要求空间复杂度O(1)
-
宏观调度就是不拘于矩阵打印的位置变换，而是着眼于单元块/接口这样的设计
-
思路：
- 两个点，(row1，col1)，（row2，col2）；
- 打印对角函数printlevel()：传入两个点+控制方向flag
- flag为正，向斜上打印；flag为负，向斜下打印；
- 退出条件为：row1越界row2/row2越界row1（col一起变化就不用写了）
- 主函数控制printZmatrix()：
- 一开始1点=2点，循环调用打印对角函数
- 调用一次后，1点向下走，越界后向右走；2点向右走，越界后向下走；同步row++/col++
- 每次flag打印完后取反，初始为负；
- 跳出打印条件：1点/2点到了右下角（是同时到的）
-
算法实现（Java）
public static void printMatrixZigZag(int[][] matrix) {
int tR = 0;
int tC = 0;
int dR = 0;
int dC = 0;
int endR = matrix.length - 1;
int endC = matrix[0].length - 1;
boolean fromUp = false;
while (tR != endR + 1) {
printLevel(matrix, tR, tC, dR, dC, fromUp);
tR = tC == endC ? tR + 1 : tR;
tC = tC == endC ? tC : tC + 1;
dC = dR == endR ? dC + 1 : dC;
dR = dR == endR ? dR : dR + 1;
fromUp = !fromUp;
}
System.out.println();
}
public static void printLevel(int[][] m, int tR, int tC, int dR, int dC,
boolean f) {
if (f) {
while (tR != dR + 1) {
System.out.print(m[tR++][tC--] + " ");
}
} else {
while (dR != tR - 1) {
System.out.print(m[dR--][dC++] + " ");
}
}
}
题目八：在行列都排好序的矩阵中查找
-
题目表述
- 给定一个N* M的整型矩阵matrix和一个整数K，matrix的每一行和每一列都是有序的。实现一个函数，判断K是否在matrix中；要求时间复杂度O(n+m)，空间复杂度O(1)
例如：
0 1 2 5
2 3 4 7
4 4 4 8
5 7 7 9
如果K=7，则返回true；若K=6，则返回false；
- 给定一个N* M的整型矩阵matrix和一个整数K，matrix的每一行和每一列都是有序的。实现一个函数，判断K是否在matrix中；要求时间复杂度O(n+m)，空间复杂度O(1)
-
思路：
- 很容易看出是找到一个初始值然后与K进行比较，小/大都往不同的方向继续走
- 选择初始值一般为左下点或者右上点，因为跟他们比较之后继续走的方向唯一。
-
算法实现（Java）
public static boolean isContains(int[][] matrix, int K) {
int row = 0;
int col = matrix[0].length - 1;
while (row < matrix.length && col > -1) {
if (matrix[row][col] == K) {
return true;
} else if (matrix[row][col] > K) {
col--;
} else {
row++;
}
}
return false;
}
题目九：打印两个有序链表的公共部分（水题）
-
题目表述：
- 给定两个有序链表的的头指针head1和head2，打印两个有序链表的公共部分
-
思路
- 谁小谁往后走，相等打印再一起走一步
题目十：判断一个链表是否是回文结构
-
题目表述：
- 给定一个链表的头节点，请判断该链表是否是回文结构，要求时间复杂度O(n)
-
思路一：额外空间O(n)
- 利用栈结构，全部遍历一遍链表入栈
- 再遍历一遍链表，比对栈顶元素与遍历元素是否相等，相等出栈继续下一个元素直至最后
-
思路二：额外空间O(n/2)
- 利用快慢两个指针，慢指针步长1，快指针步长2（Trick经常用）
- 当快指针越界时，慢指针刚好到链表的中点（如何找到链表的中点）
- 再将慢指针后续压栈，再逐一弹栈与头节点一起遍历比对元素是否相等
-
思路三：额外空间O(1)
- 与思路二相同，慢指针刚好到链表中点处
- 将慢指针后续链表逆序，覆盖原来的后半空间；半链表逆序，两头链表往中间指向，中间结点指向null，慢指针指向后半链表的表头
- 再将慢指针与头节点遍历逐一比对元素是否相等
-
算法实现（Java）
//思路一代码：
public static boolean isPalindrome1(Node head) {
Stack<Node> stack = new Stack<Node>();
Node cur = head;
while (cur != null) {
stack.push(cur);
cur = cur.next;
}
while (head != null) {
if (head.value != stack.pop().value) {
return false;
}
head = head.next;
}
return true;
}
//思路二代码：
public static boolean isPalindrome2(Node head) {
if (head == null || head.next == null) {
return true;
}
Node right = head.next;
Node cur = head;
while (cur.next != null && cur.next.next != null) {
right = right.next;
cur = cur.next.next;
}
Stack<Node> stack = new Stack<Node>();
while (right != null) {
stack.push(right);
right = right.next;
}
while (!stack.isEmpty()) {
if (head.value != stack.pop().value) {
return false;
}
head = head.next;
}
return true;
}
//思路三代码：
public static boolean isPalindrome3(Node head) {
if (head == null || head.next == null) {
return true;
}
Node n1 = head;
Node n2 = head;
while (n2.next != null && n2.next.next != null) { // find mid node 快慢指针
n1 = n1.next; // n1 -> mid
n2 = n2.next.next; // n2 -> end
}
n2 = n1.next; // n2 -> right part first node
n1.next = null; // mid.next -> null
Node n3 = null;
while (n2 != null) { // right part convert 链表逆序操作
n3 = n2.next; // n3 -> save next node
n2.next = n1; // next of right node convert
n1 = n2; // n1 move
n2 = n3; // n2 move
}
n3 = n1; // n3 -> save last node
n2 = head;// n2 -> left first node
boolean res = true;
while (n1 != null && n2 != null) { // check palindrome
if (n1.value != n2.value) {
res = false;
break;
}
n1 = n1.next; // left to mid
n2 = n2.next; // right to mid
}
n1 = n3.next;
n3.next = null;
while (n1 != null) { // recover list
n2 = n1.next;
n1.next = n3;
n3 = n1;
n1 = n2;
}
return res;
}
题目十一：单向链表按照某值划分小等大形式
-
题目表述：给定一个链表头节点head，节点值是整型，再给定一个整数pivot。实现一个调整列表的功能，使链表左边小于pivot，再是等于pivot，右边大于pivot的结点；各区域内部要求相对次序不变
- 例如：9-0-4-5-1，pivot=3；
- 调整后是：0-1-9-4-5
-
思想：
- 看到某值分区域 - 想到就是 partation - 该题就是一个partation的链表版本
-
思路一：额外空间O(n)
- 将链表的值存入一个数组里面，在数组里面进行partation - 数组随机访问时间复杂度O(1)
- partation完之后再返回拼接链表
-
思路二：额外空间O(1)
- 设三个头节点small，big，equal，第一次遍历链表，找到第一次出现的三个区域元素 - 作为头节点
- 第二次遍历链表，原节点跳过（通过内存地址 == 判断），后续节点属于哪个区域就连接到那个区域后面
- 最后再把三个链表组合即可
-
算法实现（Java）
public static class Node {
public int value;
public Node next;
public Node(int data) {
this.value = data;
}
}
//思路一
public static Node listPartition1(Node head, int pivot) {
if (head == null) {
return head;
}
Node cur = head;
int i = 0;
while (cur != null) {
i++;
cur = cur.next;
}
Node[] nodeArr = new Node[i];
i = 0;
cur = head;
for (i = 0; i != nodeArr.length; i++) { // 数组赋值
nodeArr[i] = cur;
cur = cur.next;
}
arrPartition(nodeArr, pivot);
for (i = 1; i != nodeArr.length; i++) {
nodeArr[i - 1].next = nodeArr[i];
}
nodeArr[i - 1].next = null;
return nodeArr[0];
}
public static void arrPartition(Node[] nodeArr, int pivot) { // partation过程
int small = -1;
int big = nodeArr.length;
int index = 0;
while (index != big) {
if (nodeArr[index].value < pivot) {
swap(nodeArr, ++small, index++);
} else if (nodeArr[index].value == pivot) {
index++;
} else {
swap(nodeArr, --big, index);
}
}
}
public static void swap(Node[] nodeArr, int a, int b) {
Node tmp = nodeArr[a];
nodeArr[a] = nodeArr[b];
nodeArr[b] = tmp;
}
//思路二
public static Node listPartition2(Node head, int pivot) {
Node sH = null; // small head
Node sT = null; // small tail
Node eH = null; // equal head
Node eT = null; // equal tail
Node bH = null; // big head
Node bT = null; // big tail
Node next = null; // save next node
// every node distributed to three lists
while (head != null) {
next = head.next;
head.next = null;
if (head.value < pivot) {
if (sH == null) {
sH = head;
sT = head;
} else {
sT.next = head;
sT = head;
}
} else if (head.value == pivot) {
if (eH == null) {
eH = head;
eT = head;
} else {
eT.next = head;
eT = head;
}
} else {
if (bH == null) {
bH = head;
bT = head;
} else {
bT.next = head;
bT = head;
}
}
head = next;
}
// small and equal reconnect
if (sT != null) {
sT.next = eH;
eT = eT == null ? sT : eT;
}
// all reconnect
if (eT != null) {
eT.next = bH;
}
return sH != null ? sH : eH != null ? eH : bH;
}
public static void printLinkedList(Node node) {
System.out.print("Linked List: ");
while (node != null) {
System.out.print(node.value + " ");
node = node.next;
}
System.out.println();
}
题目十二：复制含有随机指针节点的链表
- 题目表述：有一种特殊节点，它比普通节点多一个指针节点，随机指向该链表的任何一个节点或者空；请深拷贝一个这样的链表。（深拷贝 - 副本）
public static class Node {
public int value;
public Node next;
public Node rand;
public Node(int data) {
this.value = data;
}
}
-
思路一：
- 最好的方法就是用哈希表做映射关系
- 首先 Node new1=new Node(node1.value) 将所有的值先进行生成
- 再构造哈希表 map(old_node,new_node)，做节点映射
- 之后遍历原链表，构造new节点的next与rand指针节点 -
new.next=map.get(old.next)
new.rand=map.get(old.rand)
-
思路二：
- 如果不允许用哈希表，就需要用另外一种构造对应关系的方法
- 将新节点插入原节点next中间：old->new->old.next
- 之后遍历链表，一次性拿出old与new两个节点：令
new.rand=old.rand.next
new.next=new.next.next
-
算法实现（Java）
//思路一
public static Node copyListWithRand1(Node head) {
HashMap<Node, Node> map = new HashMap<Node, Node>();
Node cur = head;
while (cur != null) {
map.put(cur, new Node(cur.value));
cur = cur.next;
}
cur = head;
while (cur != null) {
map.get(cur).next = map.get(cur.next);
map.get(cur).rand = map.get(cur.rand);
cur = cur.next;
}
return map.get(head);
}
//思路二
public static Node copyListWithRand2(Node head) {
if (head == null) {
return null;
}
Node cur = head;
Node next = null;
// copy node and link to every node //每个后面都new一个新节点
while (cur != null) {
next = cur.next;
cur.next = new Node(cur.value);
cur.next.next = next;
cur = next;
}
cur = head;
Node curCopy = null;
// set copy node rand
while (cur != null) {
next = cur.next.next;
curCopy = cur.next;
curCopy.rand = cur.rand != null ? cur.rand.next : null;
cur = next;
}
Node res = head.next;
cur = head;
// split
while (cur != null) {
next = cur.next.next;
curCopy = cur.next;
cur.next = next;
curCopy.next = next != null ? next.next : null;
cur = next;
}
return res;
}
public static void printRandLinkedList(Node head) {
Node cur = head;
System.out.print("order: ");
while (cur != null) {
System.out.print(cur.value + " ");
cur = cur.next;
}
System.out.println();
cur = head;
System.out.print("rand: ");
while (cur != null) {
System.out.print(cur.rand == null ? "- " : cur.rand.value + " ");
cur = cur.next;
}
System.out.println();
}
题目十三：两个单向链表相交的一系列问题 （重要）
-
题目表述：单向链表可能有环也可能无环。给定两个链表head1和head2，这两个链表可能相交也可能不相交。请实现一个函数，若相交则返回相交第一个节点；若不相交，则返回Null。
要求：如果head1长度为N，head2长度为M，时间复杂度达到O(N+M)，空间复杂度O(1). -
首先得判断单向链表是否有环
子问题：单向链表如何判断有无环
-
如果有链表有环，返回第一个入环节点；否则返回Null
-
思路一：
-
利用哈希表：凡是跟next节点指向本链表节点的题都要想到哈希表
-
遍历链表，每个节点放到哈希表里，如果map.get(node)没有值，则无环；否则有环，有值处就是第一个入环节点
-
-
思路二：
- 不用哈希表：快F慢S指针，如果无环，则快指针一定会走到Null；如果有环，则快指针F一定会遇上慢指针S。相遇之后，快指针F回到开头，变成慢指针（即每次走一步）；然后两个慢指针会在入环节点处相遇! - （图论数学结论）
设计思路
-
getLoopNode返回单向链表环路第一个节点
-
getIntersectNode返回相交第一个节点
-
情况①：head1&head2都无环路 - noLoop
-
因为单向链表，链表只有一个分支next，所有无环路只可能两种情况：|| & Y
-
利用哈希表：将head1加入哈希表，head2进行map.get，如果有值则该值就是相交点。
-
不用哈希表：先遍历一遍，得到head1与head2长度，比较最后节点的地址，若相同则有交点，否则无； - 之后比较head1&head2长度，长的先走多余那段，之后两者同时前进，必然会在第一个交点处相遇
-
-
情况②：一个链表有环另一个无环 - 不可能出现相交
- 6 1 - 链表形状如此，1在6任何位置处都会使得1是有环链表，故无相交可能性
-
情况③：都是有环链表 - bothLoop
-
66 & 环前相交 & 环环相交
-
环前相交：即 loop1==loop2，此时以 loop环节点作为最后节点，进行调用noLoop即可。
-
环环相交：loop1 != loop2，则可能无相交&环环相交，此时让Loop1往后遍历，如果没有遇到Loop2回到原点Loop1，则是66 ；若是遇到Loop2，则是环环相交，Loop1Loop2都可作为相交点（因为是环相交）
-
-
算法实现（Java）
public static class Node {
public int value;
public Node next;
public Node(int data) {
this.value = data;
}
}
public static Node getIntersectNode(Node head1, Node head2) {
if (head1 == null || head2 == null) {
return null;
}
Node loop1 = getLoopNode(head1);
Node loop2 = getLoopNode(head2);
if (loop1 == null && loop2 == null) {
return noLoop(head1, head2);
}
if (loop1 != null && loop2 != null) {
return bothLoop(head1, loop1, head2, loop2);
}
return null;
}
public static Node getLoopNode(Node head) { // 得到环链表第一个入环节点
if (head == null || head.next == null || head.next.next == null) {
return null;
}
Node n1 = head.next; // n1 -> slow
Node n2 = head.next.next; // n2 -> fast
while (n1 != n2) {
if (n2.next == null || n2.next.next == null) {
return null;
}
n2 = n2.next.next;
n1 = n1.next;
}
n2 = head; // n2 -> walk again from head
while (n1 != n2) {
n1 = n1.next;
n2 = n2.next;
}
return n1;
}
public static Node noLoop(Node head1, Node head2) {
if (head1 == null || head2 == null) {
return null;
}
Node cur1 = head1;
Node cur2 = head2;
int n = 0;
while (cur1.next != null) {
n++;
cur1 = cur1.next;
}
while (cur2.next != null) {
n--;
cur2 = cur2.next;
}
if (cur1 != cur2) {
return null;
}
cur1 = n > 0 ? head1 : head2;
cur2 = cur1 == head1 ? head2 : head1;
n = Math.abs(n);
while (n != 0) {
n--;
cur1 = cur1.next;
}
while (cur1 != cur2) {
cur1 = cur1.next;
cur2 = cur2.next;
}
return cur1;
}
public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
Node cur1 = null;
Node cur2 = null;
if (loop1 == loop2) {
cur1 = head1;
cur2 = head2;
int n = 0;
while (cur1 != loop1) {
n++;
cur1 = cur1.next;
}
while (cur2 != loop2) {
n--;
cur2 = cur2.next;
}
cur1 = n > 0 ? head1 : head2;
cur2 = cur1 == head1 ? head2 : head1;
n = Math.abs(n);
while (n != 0) {
n--;
cur1 = cur1.next;
}
while (cur1 != cur2) {
cur1 = cur1.next;
cur2 = cur2.next;
}
return cur1;
} else {
cur1 = loop1.next;
while (cur1 != loop1) {
if (cur1 == loop2) {
return loop1;
}
cur1 = cur1.next;
}
return null;
}
}
public static void main(String[] args) {
// 1->2->3->4->5->6->7->null
Node head1 = new Node(1);
head1.next = new Node(2);
head1.next.next = new Node(3);
head1.next.next.next = new Node(4);
head1.next.next.next.next = new Node(5);
head1.next.next.next.next.next = new Node(6);
head1.next.next.next.next.next.next = new Node(7);
// 0->9->8->6->7->null
Node head2 = new Node(0);
head2.next = new Node(9);
head2.next.next = new Node(8);
head2.next.next.next = head1.next.next.next.next.next; // 8->6
System.out.println(getIntersectNode(head1, head2).value);
// 1->2->3->4->5->6->7->4...
head1 = new Node(1);
head1.next = new Node(2);
head1.next.next = new Node(3);
head1.next.next.next = new Node(4);
head1.next.next.next.next = new Node(5);
head1.next.next.next.next.next = new Node(6);
head1.next.next.next.next.next.next = new Node(7);
head1.next.next.next.next.next.next = head1.next.next.next; // 7->4
// 0->9->8->2...
head2 = new Node(0);
head2.next = new Node(9);
head2.next.next = new Node(8);
head2.next.next.next = head1.next; // 8->2
System.out.println(getIntersectNode(head1, head2).value);
// 0->9->8->6->4->5->6..
head2 = new Node(0);
head2.next = new Node(9);
head2.next.next = new Node(8);
head2.next.next.next = head1.next.next.next.next.next; // 8->6
System.out.println(getIntersectNode(head1, head2).value);
}
}
题目十四：反转单向&双向链表
-
分别实现反转单向链表双向链表函数，时间复杂度O(N)，空间复杂度O(1)
-
反转单向链表：两两节点，将next指向方向反向即可
-
反转双向链表：两两节点，将next、pre指向方向反向即可
-
-
算法实现（Java）
public static class Node {
public int value;
public Node next;
public Node(int data) {
this.value = data;
}
}
public static Node reverseList(Node head) {
Node pre = null;
Node next = null;
while (head != null) {
next = head.next;
head.next = pre;
pre = head;
head = next;
}
return pre;
}
public static class DoubleNode {
public int value;
public DoubleNode last;
public DoubleNode next;
public DoubleNode(int data) {
this.value = data;
}
}
public static DoubleNode reverseList(DoubleNode head) {
DoubleNode pre = null;
DoubleNode next = null;
while (head != null) {
next = head.next;
head.next = pre;
head.last = next;
pre = head;
head = next;
}
return pre;
}
public static void printLinkedList(Node head) {
System.out.print("Linked List: ");
while (head != null) {
System.out.print(head.value + " ");
head = head.next;
}
System.out.println();
}
public static void printDoubleLinkedList(DoubleNode head) {
System.out.print("Double Linked List: ");
DoubleNode end = null;
while (head != null) {
System.out.print(head.value + " ");
end = head;
head = head.next;
}
System.out.print("| ");
while (end != null) {
System.out.print(end.value + " ");
end = end.last;
}
System.out.println();
}
public static void main(String[] args) {
Node head1 = new Node(1);
head1.next = new Node(2);
head1.next.next = new Node(3);
printLinkedList(head1);
head1 = reverseList(head1);
printLinkedList(head1);
DoubleNode head2 = new DoubleNode(1);
head2.next = new DoubleNode(2);
head2.next.last = head2;
head2.next.next = new DoubleNode(3);
head2.next.next.last = head2.next;
head2.next.next.next = new DoubleNode(4);
head2.next.next.next.last = head2.next.next;
printDoubleLinkedList(head2);
printDoubleLinkedList(reverseList(head2));
}
