链表 插入 遍历 删除 反转 单向链表 双向链表

class Node:
    def __init__(self, val=None):
        self.val = val
        self.next = None


# 单向链表 反转链表
# doubly linked list
# singly linked list
class SLinkedList:

    def __init__(self):
        self.head = None

    def traverse(self):
        node = self.head
        while node is not None:
            print(node.val)
            node = node.next

    def reverse(self):
        if self.head is None:
            return
        newHead = None
        cur = self.head  # 当前节点
        while cur is not None:
            prior = newHead  # 原方向当前节点的前一个节点
            after = cur.next  # 原方向当前节点的后一个节点

            cur.next = prior
            newHead = cur
            cur = after

        self.head = newHead
        return


# 解题思路： 找准3个节点
list1 = SLinkedList()
list1.head = Node("H")
e1 = Node("Mon")
e2 = Node("Tue")
e3 = Node("Wed")
e4 = Node("Thur")
list1.head.next = e1
e1.next = e2
e2.next = e3
e3.next = e4

list1.traverse()
print("ok")
list1.reverse()
list1.traverse()

 leetcode的python实现-(206)反转链表和(92)反转链表II https://mp.weixin.qq.com/s/t_R5KUIGcbMiJcjESePr4g

【反转链表1和反转链表2】

leetcode(206)反转链表题目描述

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL

输出: 5->4->3->2->1->NULL

思路

开启一个头节点p1为空的新链表，对已有链表的当前节点head而言，先保存它的下一节点next的指向为temp，然后再对p1和head的next指向修改。最后返回新链表的头节点p1

# Definition for singly-linked list.from typing import Listclass ListNode:    def __init__(self, x):        self.val = x        self.next = None
class Solution:    def reverseList(self, head: ListNode) -> ListNode:        if head == None : return None        p1 = None        while head:            temp = head.next            head.next = p1            p1 = head            head =temp        return p1

测试

if __name__ == "__main__":    n1 = ListNode(1)    n2 = ListNode(2)    n3 = ListNode(3)    n4 = ListNode(4)    n5 = ListNode(5)    m=n1    n1.next=n2    n2.next=n3    n3.next=n4    n4.next=n5
    val1 = []    while m:        val1.append(m.val)        m=m.next    print('原链表节点的值:',val1)
    #反转链表    s=Solution()    node=s.reverseList(n1)    val2 =[]    while node:        val2.append(node.val)        node=node.next    print('反转后链表节点的值:',val2)#result原链表节点的值: [1, 2, 3, 4, 5]反转后链表节点的值: [5, 4, 3, 2, 1]

leetcode(92)反转链表II

题目描述

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。
示例:
输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL

思路

和上面的反转链表主体类似，关键是找到从那个节点开始反转操作，以及到哪个节点结束反转，最后注意链表节点next指针指向的连续性

class Solution:    def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:        p1 = ListNode(1)        p1.next = head        p2 = p1         t = m        while m-1:#找到开始反转的节点m            m = m-1            p2 = p2.next        p3 = p2.next        while n-t:#保证只反转到第n个节点            temp = p3.next            p3.next = temp.next            temp.next= p2.next            p2.next = temp            n = n-1        return p1.next

测试

if __name__ == "__main__":    n1 = ListNode(1)    n2 = ListNode(2)    n3 = ListNode(3)    n4 = ListNode(4)    n5 = ListNode(5)    m=n1    n1.next=n2    n2.next=n3    n3.next=n4    n4.next=n5
    val1 = []    while m:        val1.append(m.val)        m=m.next    print('原链表节点的值:',val1)    #反转链表    s=Solution()    node=s.reverseBetween(n1,2,4)    val2 =[]    while node:        val2.append(node.val)        node=node.next    print('反转后链表节点的值:',val2)# result原链表节点的值: [1, 2, 3, 4, 5]反转后链表节点的值: [1, 4, 3, 2, 5]

点击左下角【阅读原文】查看leetcode官网本题描述

【往期文章回顾】

链表

1. 剑指offer的python实现(1)-从尾到头打印链表的值

2. 剑指offer的python实现(6)-反转链表

3. 剑指offer的python实现(15)-链表中倒数第k个结点

4. 剑指offer的python实现(16)-合并两个排序的链表

5. 剑指offer的python实现(18)-删除链表中重复的结点

6. 剑指offer的python实现(20)-链表中的环的入口接点

7. 剑指offer的python实现(23)-两个链表的第一个公共结点

8. 剑指offer的python实现(27)-复杂链表的复制

9. 剑指offer的python实现(29)-二叉搜索树与双向链表

10. leetcode-19. 删除链表的倒数第N个节点

二叉树

1. 剑指offer的python实现(3)-重建二叉树

2. 剑指offer的python实现(4)-二叉树层级遍历

3. 剑指offer的python实现(5)-二叉搜索树的后序遍历序列

4. 剑指offer的python实现(21)-二叉树的镜像

5. 剑指offer的python实现(22)-树的子结构

6. 剑指offer的python实现(25)-二叉树中和为某一值的路径

7. 剑指offer的python实现(30)-二叉树的深度

8. 剑指offer的python实现(33)-平衡二叉树

9. 剑指offer的python实现(38)-二叉树的下一个结点

10. 剑指offer的python实现(39)-对称的二叉树

11. 剑指offer的python实现(40)-二叉搜索树的第k个结点

12. leetcode－二叉树的前、中、后序遍历和层序遍历python实现

13. leetcode－N叉树的前、后序遍历和层序遍历python实现

14. leetcode(98)-验证二叉搜索树

15. leetcode(235)python实现- 二叉搜索树的最近公共祖先

数组

1. leetcode(560)python实现-和为k的子数组

2. 剑指offer的python实现(46)-构建乘积数组

3. 剑指offer的python实现(35)-把数组排成最小的数

4. 剑指offer的python实现(32)-连续子数组的最大和

5. 剑指offer的python实现(31)-数组中出现次数超过一半的数字

6. 剑指offer的python实现(17)-调整数组奇偶数顺序

7. 剑指offer的python实现(9)-旋转数组的最小数字

8. 找出一维数组中的重复值-python实现

字符串

1. 剑指offer的python实现(36)-第一个只出现一次的字符位置

2. 剑指offer的python实现(42)-左旋转字符串

3. 剑指offer的python实现(45)-把字符串转换成整数

栈和队列

1. 剑指offer的python实现(7)-用两个栈实现队列

2. 剑指offer的python实现(8)-栈的压入弹出序列

3. 剑指offer的python实现(28)-包含min函数的栈

递归和循环

1. 剑指offer的python实现(10)-斐波那契数列

2. 剑指offer的python实现(11)-跳台阶

3. 剑指offer的python实现(12)-变态跳台阶

排序算法

1. 冒泡排序、选择排序、插入排序、快速排序的python实现
2. 归并排序、堆排序的python实现

3. 计数排序、桶排序、基数排序的python实现

 (1) 反转链表 - LeetCode 阅读 https://leetcode-cn.com/articles/reverse-linked-list/

双向链表

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None


class doubly_linked_list:
    def __init__(self):
        self.head = None
        self.next = None
        self.prev = None

    def push(self, data):
        newnode = Node(data)
        newnode.next = self.head
        if self.head is not None:
            self.head.prev = newnode
        self.head = newnode

    def append(self, data):
        newnode = Node(data)
        newnode.next = None
        lastnode = self.head
        while lastnode.next:
            lastnode = lastnode.next
        newnode.prev = lastnode
        lastnode.next = newnode

    def print_list(self):
        lastnode = self.head
        while lastnode.next:
            print(lastnode.data)
            lastnode = lastnode.next
        print(lastnode.data)


dl = doubly_linked_list()
dl.push('Mon')
dl.push('Thu')
dl.push('Wed')

dl.append('a1')
dl.append('a2')
dl.print_list()











【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/rsapaper/p/7440136.html