反转链表

2022-02-21 16:33:32 阅读：104 来源： 互联网

标签：node head ListNode val 反转 self next 链表

如果不在牛客网或者leetcode上运行代码 则要自己定义数据结构 如下：

定义如下：

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


class NodeHandle(object):
    def __init__(self):
        self.cur_node = None

    # 查找
    def find(self, node, num, a=0):
        while node:
            if a == num:
                return node
            a += 1
            node = node.next

    # 增加
    def add(self, data):
        node = Node()  # 实例化node
        node.val = data  # 赋值val
        node.next = self.cur_node  # 赋值next
        self.cur_node = node  # 存放上一个节点
        return node

    # 打印
    def printNode(self, node):
        while node:
            print('node: ', node, ' value: ', node.val, ' next: ', node.next)
            node = node.next

    # 删除
    def delete(self, node, num, b=1):
        if num == 0:
            node = node.next
            return node
        while node and node.next:
            if num == b:
                node.next = node.next.next
            b += 1
            node = node.next
        return node

    # 翻转
    def reverse(self, nodelist):
        list = []
        while nodelist:
            list.append(nodelist.val)
            nodelist = nodelist.next
        result = Node()
        result_handle = NodeHandle()
        for i in list:
            result = result_handle.add(i)
        return result


class Solution(object):
    def __init__(self):
        self.count = 0

    def reverse_list(self, head, n) -> Node:
        self.count += 1
        if self.count == n or n == 0 or not head:
            print("head", head)
            return head
        elif not head.next:
            return head
        headNode = self.reverse_list(head.next, n)  # 5
        head.next.next = head
        head.next = None
        return headNode


if __name__ == '__main__':
    l1 = Node()
    ListNode_1 = NodeHandle()
    l1_list = [1, 2, 3, 4, 5]
    l1_list.reverse()  # 翻转一下，下面的for是顺序添加
    for i in l1_list:
        ListNode_1.add(i)
    # print("aaa", ListNode_1.cu

Python

（一）迭代

循环了n次，时间复杂度是O(n)，但是只需要一遍，空间复杂度是O(1)

迭代法就是相当于假设有两个链表，其中一个链表是空的，我们要做的工作就是把当前链表的元素不断移动到空链表上。pre就是那个空链表，然后不断将当前链表移动到空链表上

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param head ListNode类 
# @return ListNode类
class Solution():
    def ReverseList(self, head: ListNode) -> ListNode:
        if (head == None or head.next == None):
            return head
        pre = None
        while head:
            tmp = head.next
            head.next = pre
            pre = head
            head = tmp
        return pre

（二）递归

递归法的时间复杂度比迭代法的空间复杂度要高，虽然时间复杂度是一样的，但是递归调用需要额外的时间开销，所以第一种方法是首选，但是如果被问到有没有其他的方法，如果能够说出第二种方法，那就能够起到锦上添花的效果了。

循环了n次，时间复杂度是O(n)，空间复杂度是O(N)

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

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if not head:
            return None
        if not head.next:
            return head
        headNode = self.reverseList(head.next)
        head.next.next = head
        head.next = None
        return headNode

python递归实现链表反转的理解过程：

ListNode类不多说，Python实现链表的常用形式。重点关注reverseList( )函数的实现过程。

1.首先函数进入开头的两个if语句，分别是用来判断当前节点和下一个节点是否为NULL，尤其是第二个,在后面递归过程中也会用到。

2.然后开始进入递归，注意传给 self.reverseList( ) 的参数为 head.next ,也就是说链表的会一直往后传递，直到找到最后一个节点（也就是head.val == 5的节点，后文简述为节点5）。此时，因为不满足第二个if语句，返回节点5。

我们可以在第二个if语句中加入一行print( head.val ) ，这样可以更容易看出返回的内容。

3.函数在第二步返回到递归的上一层，headNode 等于返回的节点5 , 也就是节点5作为反转的链表头，完成反转的第一步。

4. 当前节点head为节点4 , head.next指向节点5， head.next.next指向None。 head.next.next= head 让原来指向None的节点5，改为指向节点4，完成了5—>None到5—>4的反转；然后head.next = None , 作用在于截断节点4到节点5的指针，避免形成4—>5—>4的环。

5.同理，返回上一层，当前节点head为节点3，让节点4指向节点3，再截断节点3到节点4的指针。

6.如此重复，直到反转所有节点，headNode即为反转后的链表。

Java

迭代

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode pre = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}

递归

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode node = this.reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return node;
    }
}

标签：node,head,ListNode,val,反转,self,next,链表
来源： https://www.cnblogs.com/chenxiaomeng/p/15919416.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

反转链表

定义如下：

Python

Java