迭代/递归创建链表

Question

Need to recursively or iteratively create a linked list for a given number string.

For example: Number = "123" 1 -> 2 -> 3

I wrote a recursive function but doesn't seem to work, it is creating a linked list but without the middle values. 1 -> 3 instead of 1 -> 2 -> 3

def create_linked_list(head, num):
    if num is "":
        return head
    else:
        head.next = ListNode(num[0])
        return create_linked_list(head.next, num[1:])

n = "123"
head = ListNode(n[0])
result = create_linked_list(head, n[1:])

while result:
    print(result.val)
    head = result.next
# This is printing 1 -> 4

This is the original use case

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

n = "1234"

# I need this part of linked list creation to be done
# in a looping/recursive manner for any kind of number.
l1 = ListNode(n[0])
l1.next = ListNode(n[1])
l1.next.next = ListNode(n[2])
l1.next.next.next = ListNode(n[3])


while l1:
    print(l1.val)
    head = l1.next
# 1 -> 2 -> 3 -> 4

Answer 1

• Your recursive approach looks correct. Only thing you need to do is. you don't need to return head when you reach end of number. Because you are already storing head in head variable.
• Here is code that works.

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

n = "1234"
def create_linked_list(head, num):
    if num is "": #base condition.
        return
    else:
        head.next = ListNode(num[0])
        create_linked_list(head.next, num[1:])

head = ListNode(n[0])
temp = head
create_linked_list(head, n[1:])

while temp:
    print(temp.val)
    temp = temp.next

• Output

  1
  2
  3
  4

• You can also rewrite above code as following.

def create_linked_list(head, num):
    if num is not "":
        head.next = ListNode(num[0])
        create_linked_list(head.next, num[1:])

• PS : Remember to always back up your head when working with Linked Lists.

Answer 2

Recursion is a functional heritage and so writing our program in functional style yields the best results. This means we avoid things like mutating the list nodes, head.next =... . Your constructor should be able to set both val and next -

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

def create_llist(v = None, *vals):
  if not v:
    return None
  else:
    return node(v, create_llist(*vals))

def llist_to_str(l = None):
  if not l:
    return "None"
  else:
    return f"{l.val} -> {llist_to_str(l.next)}"

print(llist_to_str(create_llist(1, 2, 3)))
# 1 -> 2 -> 3 -> None

But create_llist and llist_to_str would probably be more consistent if we implemented them as part of the class. And maybe a better name is llist , for "linked list" -

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

  def create(v = None, *more):
    if not v:
      return None
    else:
      return llist(v, llist.create(*more))

  def __str__(self):
    return f"{self.val} -> {self.next}"

print(llist.create(1, 2, 3))
# 1 -> 2 -> 3 -> None

Instead of relying on side effects, functions take inputs and produce an output. As a result, notice how we our mind is free of complexity -

class llist:
  # ...
  def map(node = None, f = lambda x: x):
    if not node:
      return None
    else:
      return llist(f(node.val), llist.map(node.next, f))

print(llist.map(llist.create(7, 8, 9), lambda x: x * x))
# 49 -> 64 -> 81 -> None