My code:
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
public class Solution {
public ListNode deleteDuplicates(ListNode head) {
if (head == null || head.next == null)
return head;
ListNode dummy = new ListNode(Integer.MIN_VALUE);
dummy.next = head;
ListNode pre = dummy;
ListNode curr = pre.next;
ListNode post = curr.next;
boolean isDuplicated = false;
while (curr != null) {
if (post == null) {
if (isDuplicated) {
curr = null;
pre.next = null;
}
else
break;
}
else if (curr.val == post.val) {
curr.next = post.next;
post = curr.next;
isDuplicated = true;
}
else if (curr.val != post.val) {
if (isDuplicated) {
pre.next = curr.next;
curr = post;
post = curr.next;
isDuplicated = false;
}
else {
pre = curr;
curr = post;
post = post.next;
}
}
}
return dummy.next;
}
}
這次題目不難。
Paste_Image.png
這是我當時畫的圖。
看了就基本清楚了。當然還需要分成兩種情況
如果是發現重復，并且已經刪除完了，那么pre不需要移動。否則就要移動一格。
同樣的，如果發現post已經是null了，可能是兩種情況。
現在過來看，還是代碼寫的太復雜。感覺是那幾天睡眠不好，所以腦子是糊涂得。
簡化代碼如下：
public ListNode swapPairs(ListNode head) {
if (head == null || head.next == null)
return head;
ListNode dummy = new ListNode(Integer.MIN_VALUE);
dummy.next = head;
ListNode pre = dummy;
ListNode slow = pre.next;
ListNode fast = slow.next;
while (fast != null) {
ListNode temp = fast.next;
pre.next = fast;
fast.next = slow;
slow.next = temp;
pre = slow;
slow = pre.next;
if (slow == null)
break;
fast = slow.next;
}
return dummy.next;
}
**
總結： 鏈表操作
當需要進行刪除操作，交換操作，涉及前后兩個結點的時候，
可以用 pre 指向頭一個結點的前一個結點。
curr指向頭一個結點，
detect指向下一個或幾個結點。
然后循環的判斷條件就是，detect是否為空。
然后再加上一些實現細節，根據不同的題目。
**
Anyway, Good luck, Richardo!
My code:
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
public class Solution {
public ListNode deleteDuplicates(ListNode head) {
if (head == null || head.next == null)
return head;
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode pre = dummy;
ListNode curr = head;
while (curr != null) {
if (curr.next != null && curr.val == curr.next.val) { // if current value = next value
curr = curr.next;
}
else {
if (pre.next != curr) { // if previous inequal node is not ajacent to current one, start to delete
pre.next = curr.next;
curr = pre.next;
}
else { // if previous inequal node is ajacent to current one, move on
pre = pre.next;
curr = curr.next;
}
}
}
return dummy.next;
}
}
第一個版本的代碼好復雜。這次寫的感覺還是比較明確簡潔啊。
也沒什么好說的。
Anyway, Good luck, Richardo!
My code:
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
public class Solution {
public ListNode deleteDuplicates(ListNode head) {
if (head == null || head.next == null) {
return head;
}
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode curr = head;
ListNode pre = dummy;
ListNode post = head.next;
while (post != null) {
if (post.val == curr.val) {
post = post.next;
}
else if (post != curr.next) {
pre.next = post;
curr = post;
post = post.next;
}
else {
pre = pre.next;
curr = curr.next;
post = post.next;
}
}
if (curr.next != null) {
pre.next = null;
}
return dummy.next;
}
}
類似于三個指針，然后刪除操作。
I 的情況是雙指針。
不難。
Anyway, Good luck, Richardo! -- 08/16/2016
