链表操作基础（python）创建、合并、删除、翻转

1. 创建链表，2.合并链表，3.删除链表中的元素，4.翻转链表中的一段位置的元素

# 链表节点
class ListNode(object):
    def __init__(self,val=0,next=None):
        self.val=val
        self.next=next

# 链表操作
class SinglyLinkedList(object):
    # 创建链表
    def create(self,list):
        lenth=len(list)
        if lenth==0:
            return None
        head=ListNode(list[0],None)
        tail=head
        for i in range(lenth-1):
            node=ListNode(list[i+1],None)
            tail.next=node
            tail=node
        return head
    # 浏览链表
    def scan(self,linkedlist):
        tail=linkedlist
        list=[]
        while(tail):
            list.append(tail.val)
            tail=tail.next
        return list

---

2. 将两个链表合并为一个升序链表（LeetCode 例21.）
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
输入：l1 = [], l2 = []
输出：[]

# 链表合并
class Solution(object):
    def mergeTwoLists(self, l1, l2):
        if not l1 and not l2:
            return l1
        elif not l1 and l2:
            return l2
        elif l1 and not l2:
            return l1
        tail1=l1
        tail2=l2
        if tail1.val

---

3. 删除链表中重复的元素（LeetCode 例82.）
输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]
输入：head = [1,1,1,2,3]
输出：[2,3]

解析：

class Solution(object):
    def deleteDuplicates(self, head):
        v=ListNode()
        v.next=head    # 虚拟指针防止开头部分重复导致head节点删除
        p=v
        q=p.next
        flag=0
        while(q and q.next):   # q:链表是否是空链表 q.next:是否是链表最后一个元素
            if p.next.val==q.next.val:
                q=q.next
                flag=1
            else:
                if flag==0:
                    p=p.next
                    q=p.next
                else:
                    p.next=q.next
                    q.next=None
                    q=p.next
                    flag=0
        if p.next!=q:       # 链表结尾处重复
            p.next=None
        return v.next

3. 删除链表倒数第n个元素，并返回头结点（一次扫描实现）
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
输入：head = [1], n = 1
输出：[]

# 一趟扫描实现   （比较费内存）
class Solution(object):
    def removeNthFromEnd(self, head, n):
        listNode=[]
        tail=head
        # list中每个元素指向链表节点中的每个元素
        while(tail):
            listNode.append(tail)
            tail=tail.next
        num=len(listNode)
        if num==1:    # 如果链表只有一个元素
            return None
        if num==n:    # 如果删除链表表头
            head=listNode[0].next
            listNode[0].next=None
            return head
        listNode[num-n-1].next=listNode[num-n].next
        listNode[num-n].next=None
        return head

---

 4. 翻转链表中指定位置的元素  （leetcode 例92.）
输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]
输入：head = [5], left = 1, right = 1
输出：[5] 

# 设置一个虚拟指针
class Solution(object):
    def reverseBetween(self, head, left, right):
        v=ListNode()   # 设置一个虚拟指针
        v.next=head
        num=1
        while(num

# 主函数
if __name__=='__main__':
    l1 = []
    l2 = [0]
    link=SinglyLinkedList()
    link1=link.create(l1)
    link2=link.create(l2)
    mm=Solution()
    link3=mm.mergeTwoLists(link1,link2)
    print(link.scan(link3))