leetcode-19：給定一個鏈表，刪除鏈表的倒數第 n 個節點，並且返回鏈表的頭結點。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */

 

方法：兩次遍歷算法
思路

我們注意到這個問題可以容易地簡化成另一個問題：刪除從列表開頭數起的第 (L - n + 1)(L−n+1) 個結點，其中 LL 是列表的長度。只要我們找到列表的長度 LL，這個問題就很容易解決。

算法

首先我們將添加一個啞結點作為輔助，該結點位於列表頭部。啞結點用來簡化某些極端情況，例如列表中只含有一個結點，或需要刪除列表的頭部。在第一次遍歷中，我們找出列表的長度 LL。然后設置一個指向啞結點的指針，並移動它遍歷列表，直至它到達第 (L - n)(L−n) 個結*

點那里。我們把第 (L - n)(L−n) 個結點的 next 指針重新鏈接至第 (L - n + 2)(L−n+2) 個結點，完成這個算法。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        int length = 0;
        ListNode first = head;
        while (first != null){
            length++;
            first = first.next;
        }
        
        length = length-n;
        first = dummy;
        while (length > 0){
            length--;
            first = first.next;
                
        }
        first.next = first.next.next;
        return dummy.next;
            
    }
}
// 以下為調試代碼～～
public class MainClass {
    public static int[] stringToIntegerArray(String input) {
        input = input.trim();
        input = input.substring(1, input.length() - 1);
        if (input.length() == 0) {
          return new int[0];
        }
    
        String[] parts = input.split(",");
        int[] output = new int[parts.length];
        for(int index = 0; index < parts.length; index++) {
            String part = parts[index].trim();
            output[index] = Integer.parseInt(part);
        }
        return output;
    }
    
    public static ListNode stringToListNode(String input) {
        // Generate array from the input
        int[] nodeValues = stringToIntegerArray(input);
    
        // Now convert that list into linked list
        ListNode dummyRoot = new ListNode(0);
        ListNode ptr = dummyRoot;
        for(int item : nodeValues) {
            ptr.next = new ListNode(item);
            ptr = ptr.next;
        }
        return dummyRoot.next;
    }
    
    public static String listNodeToString(ListNode node) {
        if (node == null) {
            return "[]";
        }
    
        String result = "";
        while (node != null) {
            result += Integer.toString(node.val) + ", ";
            node = node.next;
        }
        return "[" + result.substring(0, result.length() - 2) + "]";
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = in.readLine()) != null) {
            ListNode head = stringToListNode(line);
            line = in.readLine();
            int n = Integer.parseInt(line);
            
            ListNode ret = new Solution().removeNthFromEnd(head, n);
            
            String out = listNodeToString(ret);
            
            System.out.print(out);
        }
    }
}

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        dummy = ListNode(0)
        dummy.next = head
        length = 0
        first = head
        while first:
            length = length + 1
            first = first.next
        length = length - n
        first = dummy
        while length:
            length = length -1
            first = first.next
            
        first.next = first.next.next
        return dummy.next

def stringToListNode(input):
    # Generate list from the input
    numbers = json.loads(input)

    # Now convert that list into linked list
    dummyRoot = ListNode(0)
    ptr = dummyRoot
    for number in numbers:
        ptr.next = ListNode(number)
        ptr = ptr.next

    ptr = dummyRoot.next
    return ptr

def stringToInt(input):
    return int(input)

def listNodeToString(node):
    if not node:
        return "[]"

    result = ""
    while node:
        result += str(node.val) + ", "
        node = node.next
    return "[" + result[:-2] + "]"

def main():
    import sys
    def readlines():
        for line in sys.stdin:
            yield line.strip('\n')
    lines = readlines()
    while True:
        try:
            line = lines.next()
            head = stringToListNode(line)
            line = lines.next()
            n = stringToInt(line)
            
            ret = Solution().removeNthFromEnd(head, n)

            out = listNodeToString(ret)
            print out
        except StopIteration:
            break

if __name__ == '__main__':
    main()