LeetCode刷题--点滴记录009

要求

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

解题

#include 
using namespace std;

struct ListNode {
    int val;        // 节点值
    ListNode* next; // 后继节点引用
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(NULL) {}
    ListNode(int x, ListNode*next) : val(x), next(next) {}
};

void printList(ListNode* phead)//输出
{
    ListNode* p = phead;
    while (p != NULL)
    {
        cout << p->val << " ";
        p = p->next;
    }
    cout << endl;
}

class Solution {
public:
    ListNode* reverseList01(ListNode* head) {
        ListNode* cur = head;
        ListNode* pre = nullptr;
        while (cur != nullptr) {
            ListNode* tmp = cur->next; // 暂存后继节点 cur.next
            cur->next = pre;           // 修改 next 引用指向
            pre = cur;                 // pre 暂存 cur
            cur = tmp;                 // cur 访问下一节点
        }
        return pre;
    }

    ListNode* reverseList02(ListNode* head)
    {
        if (head == nullptr||head->next == nullptr)
        {
            return head;
        }
        else
        {
            ListNode* newHead = reverseList02(head->next);
            head->next->next = head;
            head->next = nullptr;
            return newHead;
        }
    }
};

void test01()
{
    Solution s;
    ListNode* list1 = new ListNode(0, new ListNode(1,new ListNode(2,new ListNode(3,new ListNode(4)))));
    printList(list1);
    printList(s.reverseList01(list1));
    ListNode* list2 = new ListNode(5, new ListNode(6, new ListNode(7, new ListNode(8, new ListNode(9)))));
    printList(list2);
    printList(s.reverseList02(list2));
}

int main()
{
    test01();

    system("pause");
    return 0;
}

class ListNode:
    def __init__(self, x):
        self.val = x     # 节点值
        self.next = None # 后继节点引用
        
def print_ListNode(node):
    while node:
        print(node.val, end=' ')
        node = node.next
    print()    
    
class Solution:
    def reverseList01(self, head):
        cur = head
        pre = None
        if not head or not head.next:
            return head
        while cur:
            tmp = cur.next # 暂存后继节点 cur.next
            cur.next = pre # 修改 next 引用指向
            pre = cur      # pre 暂存 cur
            cur = tmp      # cur 访问下一节点
        return pre
 
    def reverseList02(self, head):
        if head == None or head.next == None:
            return head
        #继续递归后一个节点
        newHead = self.reverseList02(head.next)
        #反转节点
        head.next.next = head
        head.next = None
        return newHead

def test01():
    solution = Solution()
    # 实例化节点
    n1 = ListNode(1) # 节点 head
    n2 = ListNode(2)
    n3 = ListNode(3)
    n4 = ListNode(4)
    n5 = ListNode(5)

    # 构建引用指向
    n1.next = n2
    n2.next = n3
    n3.next = n4
    n4.next = n5
    print_ListNode(n1)

    # print_ListNode(solution.reverseList01(n1))
    print_ListNode(solution.reverseList02(n1))
            
if __name__=="__main__":
    test01()

package com.hailei_01;

public class reverseList {
    public static void main(String[] args) {
        ListNode list1 = new ListNode(1,new ListNode(2,new ListNode(3,new ListNode(4,new ListNode(5)))));
        printListNode(list1);
        printListNode(reverseList01(list1));
        ListNode list2 = new ListNode(6,new ListNode(7,new ListNode(8,new ListNode(9,new ListNode(10)))));
        printListNode(list2);
        printListNode(reverseList02(list2));
    }

    public static class ListNode {
        int val;
        ListNode next;
        ListNode(int x) { val = x; };
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }
    public static ListNode reverseList01(ListNode head) {
        if (head == null) {
            return head;
        }
        ListNode cur = head; // 指向头结点
        ListNode pre = null; // 空
        while (cur != null) {
            ListNode temp = cur.next; // 暂存后继节点
            cur.next = pre;   // 修改next引用指向
            pre = cur;        // 暂存
            cur = temp;    // 访问下一节点
        }
        return pre;
    }

    public static ListNode reverseList02(ListNode head) {
        return recur(head, null);    // 调用递归并返回
    }

    public static ListNode recur(ListNode cur, ListNode pre) {
        if (cur == null) return pre; // 终止条件
        ListNode res = recur(cur.next, cur);  // 递归后继节点
        cur.next = pre;              // 修改节点引用指向
        return res;                  // 返回反转链表的头节点
    }

    public static void printListNode(ListNode headNode) {
        ListNode listNode = headNode;
        while(listNode!=null) {
            System.out.print(listNode.val+" ");
            listNode = listNode.next;
        }
        System.out.println();
    }
}

希望本文对大家有帮助，上文若有不妥之处，欢迎指正

分享决定高度，学习拉开差距