系列文章目录
目录
1.两个链表都是无环（loop1==null&&loop2==null）
前言
本文讲链表（待补充完整）
一、哈希表
增删改查的操作认为时间复杂度都是常数时间；
存入为基础类型时，内部值传递，占用实际大小；
存入不是基础类型时，按引用传递，占用内存地址的大小。
二、有序表
三、链表的基础题
基础题多练练就OK（待补充）
四、链表特殊题
1.打印两个有序链表的公共部分
因为是有序链表，所以从两个链表的头开始进行如下判断：
如果head1的值小于head2 ,则head1 往下移动，
如果head2的值小于head1 ,则head2 往下移动，
如果head1和head2的值相等，则打印这个值，然后head1和head2都往下移动，
head1和head2有任何一个移动到null，则整个过程停止。
链表问题节省空间的方法：
1）额外数据结构记录（哈希表等）
2）快慢指针
2.判断一个链表是否为回文结构
1.栈
把链表的全部内容依次放入栈中，再依次弹出栈中元素，并与链表依次进行比较，如果都相等，那么为回文结构，否则不是
时间复杂度：O(N)
空间复杂度：O(N)
2.栈＋快慢指针
使用快慢指针，快指针结束的时候，慢指针走到中点。
只把链表的右侧内容依次放入栈中，再依次弹出栈中元素，并与链表左侧依次进行比较，如果都相等，那么为回文结构，否则不是。
通过快慢指针找到中点：
快指针一次走两步，慢指针一次走一步，当快指针走到结尾时，慢指针走到一半，然后把慢指针后面的部分，放到栈中
时间复杂度：O(N)
空间复杂度：O(N/2)
3.改链表
改变链表右侧区域，使整个右半区域反转，最后指向中间结点；利用指针分别从两端移动，每移动一次比较两值是否一样。返回true或false之前把链表恢复成原来的样子。
空间复杂度：O(1)
// need O(1) extra space
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;//用于记录n2原本的下一个node
//右半部分逆序
while (n2 != null) { // right part convert
n3 = n2.next; // n3 -> save next node，保留未改变的链表
n2.next = n1; // next of right node convert，改变链表指向
//n1，n2两个指针完成改变指向操作后，同时右移，准备下一个元素的链表指向逆序
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，n2从中间开始走
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;
}
3.将单向链表按某值划分成左边小、中间相等、右边大的形式
1.数组+荷兰国旗（笔试）
创建node数组，把链表的node烤进去，再做partition，快速排序，即归并的3.0版本。
2.多指针划区域（进阶）
- 将原链表中的所有节点依次分为三个链表，small，equal和big。
- 将三个链表重新串起来即可
- 整个过程需要注意对null节点的判断和处理。
使用6个变量指针，小于区域的头和尾，等于区域的头和尾，大于区域的头和尾，最后将3个区域连起来的时候，要注意是否有区域为空。
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;
}
4. 复制含有随机指针节点的链表
1.hashmap
采用一个Hash表，老结点的内存地址作为KEY值，从老结点中复制得来的新结点内存地址作为VALUE值，当结点遍历完毕后，所有的新旧结点均拷贝完毕。
从头遍历老链表，每遍历一个结点，就得出他的rand和next指针，然后因为next指针和rand指针都是作为Hash表key存在，所以可以依据这个next和rand指针经由hash函数得出其对应新结点的所在地址（假设为N和R），再根据当前结点和哈希函数，得出当前结点的新结点，然后再设置新结点的next和rand指针分别指向N和R，重复步骤二，直到链表遍历完毕。
第一次遍历旧链表，使用哈希map，key为旧链表，value为新链表，新链表只是单纯地串起来并拷贝int value值，rand没有设置；第二次遍历旧链表，调用key-value，设置rand node。
2.原地克隆
为每一个结点生成一个克隆结点，克隆结点只包含原结点的data值，将其作为对应老结点的下一个结点。比如对于链表 1 -> 2 -> 3 -> null，其中1的rand域指向3，2的rand域指向1；按照该规则，链表则变化为 1 -> 1’ -> 2 -> 2’ -> 3 -> 3’ -> null；
采用双指针pre和cur，pre始终指向cur的前一个结点，cur为当前遍历结点，当cur遍历到克隆节点时，比如1’，则pre指向该克隆节点的原结点，此时通过pre.rand.next即可得到cur结点（即1’）的rand指针指向的地址，随后cur跳到下一个旧结点(指2)，如此直到遍历到链表空结点。
将新的链表进行撕裂，分成两个链表，一个全部由新结点组成，另一个全部由旧结点组成，然后返回全部由克隆节点组成的链表表头。
第一次遍历旧链表，不用哈希map，在旧map中，插入克隆node，拷贝int value值；第二次遍历链表，一对一对处理，设置rand node；第三次遍历，把旧节点删除。省去了hashmap的空间。
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
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;
}5.判断链表有无环
1.哈希表
遍历所有节点，每次遍历到一个节点时，判断该节点此前是否被访问过。
具体地，可以使用哈希表来存储所有已经访问过的节点。每次到达一个节点，如果该节点已经存在于哈希表中，则说明该链表是环形链表，否则就将该节点加入哈希表中。重复这一过程，直到遍历完整个链表即可。
2.快慢指针
让一个指针走的快一点，另外一个走的慢一点， 如果在移动的过程中，快指针反过来追上慢指针，就说明该链表为环形链表。否则快指针将到达链表尾部，该链表不为环形链表。
如果快慢指针相遇，相遇后快指针回到链表头部，慢指针停留在相遇处。之后两个指针都每次走一步，当两个指针再次相遇时就是第一个入环节点处。
//获取环的入口
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;
}
6.两个单链表相交
1.两个链表都是无环（loop1==null&&loop2==null）
只可能是2条线，或者y型线，不可能是x型，x型就是节点处next指针指向2个地方，这是不可能的。2个链表如果相交，那么他们end端一定是地址一样的，2个链表都遍历。如果相交，要找到节点处，长的列表先走长链表的长度减去短链表的长度，如此便可以一起走，一定会在交点处相遇。
public static Node noLoop(Node head1, Node head2) {
if (head1 == null || head2 == null) {
return null;
}
Node cur1 = head1;
Node cur2 = head2;
int n = 0;//用于记录长度，先记录链表1长度，然后
//减去链表2的长度，差值的绝对值，就是长度差值
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;
}
2.一个有环一个无环必然不相交
3.两个都有环
1.两个不相交，有不同的环
2.入环节点是同一个
分别找到入环节点，如果入环节点相同，就使用上面的无环代码去找相交节点。
3.入环节点不是同一个，但相交
让loop1继续走，在走会自己之前，判断会不会遇到loop2这个入口节点，遇到就是，没有就是1。
//两个有环链表。返回第一个相交节点，如果不想交返回null
//loop1,loop2分别为2个链表的环入口处节点
public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
Node cur1 = null;
Node cur2 = null;
if (loop1 == loop2) {//如果入环节点相同，是情况3-2
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 {//如果入环节点不同，是情况3-1或3-3
cur1 = loop1.next;
while (cur1 != loop1) {
if (cur1 == loop2) {
return loop1;//情况3-3
}
cur1 = cur1.next;
}
return null;//情况3-1
}
}
总结
这一部分需要先把简单题敲熟，特殊的记下思路，也多敲几遍。
627
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
