python 反转链表、两数相加、两数之和 包括输入输出、数据结构创建

 直接上代码

反转链表：

这个题在LeetCode中是简单级别...

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
 

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-linked-list

import copy


class ListNode:
    def __init__(self, num, next_node=None):
        self.num = num
        self.next = next_node


def create_node(a, *args) -> ListNode:
    head_node = ListNode(a)
    next_tem = head_node
    # tem_t = ListNode(b)
    # tem_t.next = ListNode(c)
    for i in args:
        tem_t = ListNode(i)
        next_tem.next = tem_t
        next_tem = tem_t

    return head_node


def reverse_node(head: ListNode) -> ListNode:
    old = head
    new = None
    while old is not None:
        tem = old.next
        old.next = new
        new = old
        old = tem
    return new


def print_node(node_p: ListNode):
    head = node_p
    while head.next is not None:
        print(head.num + '->', end='')
        head = head.next

    print(head.num + '->null', end=' ')
    head = head.next

    print()


if __name__ == '__main__':

    while True:
        print('输入字符，空格隔开，回车结束（-1结束程序）：')
        list_in = input().split(' ')
        print('输入结果：', end='')
        print(list_in)
        if list_in[0] == '-1':
            break

        node = create_node(*list_in)

        node_old = copy.deepcopy(node)
        node_reverse = reverse_node(node)

        print('老链表：', end='')
        print_node(node_old)
        print('新链表：', end='')
        print_node(node_reverse)
        print()

执行结果：

 

两数相加：

           简介：给定一个列表和目标值，输出对应列表下标

代码：

def answer(list_n, number_sum) -> list[int]:
    for i in range(len(list_n)-1, 0, -1):
        tem = number_sum - list_n[i]
        # print(tem)
        if tem in list_n and list_n.index(tem) != i:
            res = [list_n.index(tem), i]
            return res


if __name__ == '__main__':
    list_num = input().split()
    list_num = [int(i) for i in list_num]
    sum_number = int(input())
    list_res = answer(list_num, sum_number)
    print(list_res)

比较简单，就不多说了

两数相加（链表）

# 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

# 请你将两个数相加，并以相同形式返回一个表示和的链表。

# 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

# 示例 1：

# 输入：l1 = [2,4,3], l2 = [5,6,4]

# 输出：[7,0,8]

# 解释：342 + 465 = 807.

from typing import Optional


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


class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        list_1 = get_list_node(node_reverse(l1))
        list_1_2 = [str(i) for i in list_1]
        list_2 = get_list_node(node_reverse(l2))
        list_2_2 = [str(i) for i in list_2]

        num_1 = int(''.join(list_1_2))
        num_2 = int(''.join(list_2_2))
        sum_num = num_1 + num_2
        print(sum_num)
        sum_list = []
        while sum_num/10 != 0:
            sum_list.append(sum_num % 10)
            sum_num = int(sum_num/10)
        end_node = create_node(*sum_list)
        return end_node


def create_node(node_val_1, *args):
    node1 = ListNode(node_val_1)
    tem_next = node1
    for i in args:
        tem_node = ListNode(i)
        tem_next.next = tem_node
        tem_next = tem_node
    return node1


def get_list_node(list_node: ListNode):
    res_l = []
    while list_node is not None:
        res_l.append(list_node.val)
        list_node = list_node.next
    return res_l


def node_reverse(head:ListNode):
    old = head
    new = None
    while old is not None:
        tem = old.next
        old.next = new
        new = old
        old = tem
    return new


if __name__ == '__main__':
    node_1 = create_node(2, 4, 3)
    node_2 = create_node(5, 6, 4)
    res = Solution().addTwoNumbers(node_1, node_2)
    print(get_list_node(res))