Leetcode - 19. Remove Nth Node From End of List

题目里遇到关于python的类

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

一次遍历和两次遍历两种方法，但是不是很熟悉类的用法，所以就把链表的增删遍历做了一遍。题目答案和链表类(python) 如下：

# 两次遍历
class Solution:
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        node = head
        length = 1
        while node.next != None:
            length += 1
            node = node.next
        n = length - n + 1
        if n == 1:
            return head.next
        i = 0
        rnode = head
        while i < length:
            i += 1
            if i == n:
                preNode.next = rnode.next
            else:
                preNode = rnode
                rnode = rnode.next

        return head
# 一次遍历
class Solution:
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        first = head
        p = head.next
        i = 1
        while i < n:
            p = p.next
            i += 1
        second = p
        if second == None:
            head = head.next
            if head == None:
                return []
            else:
                return head

        while second.next != None:
            first = first.next
            second = second.next

        preNode = first
        preNode.next = first.next.next

        return head

class LNode(object):
    def __init__(self, data, p=0):
        # p 有利于传参, 存在一个指针是指向当前节点的下一个节点
        self.val = data
        self.next = p

class List(object):
    def __init__(self):
        self.head = None

    def initList(self, data):
        self.head = LNode(data[0])
        # node = self.head
        '''
        如果没有ｐ，在对data建立链表的时候就会非常的不方便
        '''
        p = self.head
        for data in data[1:]:
            node = LNode(data)
            # node.next
            p.next = node
            p = p.next

        return self.head

    # 链表判空
    def isEmpty(self):
        if self.head.next == 0:
            return 1
        else:
            return 0

    # 获取链表长度
    def getLength(self):
        if self.isEmpty():
            return 0

        length = 0
        p = self.head
        while p:
            length += 1
            p = p.next
        return length

    # 遍历链表
    def travelList(self):
        if self.isEmpty():
            exit(0)

        p = self.head
        # while p.next != 0:
        #     print(p.val)
        #     p = p.next
        # print(p.val)
        while p:
            print(p.val)
            p = p.next

    # 链表插入数据函数
    def insetElem(self, key, index):
        len = self.getLength()
        if index < 0 or index > len-1:
            exit(0)
        else:
            p = self.head
            i = 0
            while i < index:
                preNode = p
                p = p.next
                i += 1

        newNode = LNode(key)
        preNode.next = newNode
        newNode.next = p

    # 链表删除数据函数
    def deleteElem(self, index):
        len = self.getLength()
        if index < 0 or index > len-1:
            exit(0)
        else:
            p = self.head
            while index != 0:
                preNode = p
                p = p.next
                index -= 1

            preNode.next = p.next
            return 1


data = [1,2,3,4,5]
l = List()
l.initList(data)
# l.travelList()
#
# print(l.getLength())

l.insetElem(666,4)
l.deleteElem(4)
l.travelList()