[剑指 Offer 35. 复杂链表的复制]
/*
// Definition for a Node.
class Node {
int val;
Node next;
Node random;
public Node(int val) {
this.val = val;
this.next = null;
this.random = null;
}
}
*/
class Solution {
public Node copyRandomList(Node head) {
if(head==null) return null;
Node cur=head;
//利用哈希表 map,key为 旧节点,value 为新节点:
Map<Node,Node> map=new HashMap<Node,Node>();
while(cur!=null){
//顺序遍历原链表,将旧新节点键值对关系存储到哈希表map中。
map.put(cur,new Node(cur.val));
cur=cur.next;
}
cur=head;
//再次从头遍历原链表,从 map 中通过旧节点取出新节点,构建新链表:
while(cur!=null){
map.get(cur).next=map.get(cur.next);
map.get(cur).random=map.get(cur.random);
cur=cur.next;
}
return map.get(head);
}
}
剑指 Offer 06. 从尾到头打印链表(简单)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public int[] reversePrint(ListNode head) {
LinkedList<Integer> A=new LinkedList<Integer>();
ListNode p=head;
int ans=0;
while(p!=null){
ans++;
A.addFirst(p.val);
p=p.next;
}
int b[]=new int[ans];
int i=0;
while(!A.isEmpty()){
b[i++]=A.getFirst();
A.removeFirst();
}
return b;
}
}
剑指 Offer 24. 反转链表(简单)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode reverseList(ListNode head) {
LinkedList<ListNode> A=new LinkedList<ListNode>();
ListNode p=head;
while(p!=null){
A.addFirst(p);
p=p.next;
}
ListNode q = new ListNode(-1);
p=q;
while(!A.isEmpty()){
p=p.next=A.getFirst();
A.removeFirst();
}
p.next=null;
return q.next;
}
}
class Solution {
public ListNode reverseList(ListNode head) {
ListNode pre = null, cur = head, next = null;
while(cur != null) {
next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
return pre;
}
}