问题：
您有两个由链表表示的数字，其中每个节点包含一个数字。数字以相反的顺序存储，使得 1 的数字位于列表的开头。编写一个函数，将两个数字相加，并将总和作为链表返回。
举个例子：
输入：(7-> 1 -> 6( + (5 -> 9 -> 2(。
即：617 + 295。
输出： 2 -> 1 -> 9.
即：912。
为了从这个问题开始，我首先创建了一个类来定义链表：
步骤 1：定义链表
class Node: CustomStringConvertible{
var value: Int
var next: Node?
var description: String{
if next != nil {
return "(value) -> (next!)"
}
else{
return "(value) -> (next)"
}
}
init(value: Int) {
self.value = value
}
}
步骤：2 - 根据用户输入的整数值生成链表
func generateList (num: Int) -> Node {
var stringNum = Array(String(num).characters)
let head = Node.init(value:Int(String(stringNum.first!))!)
var current = head
for i in 1..<stringNum.count{
let num = Int(String(stringNum[i]))
current.next = Node.init(value: num!)
current = current.next!
}
return head
}
let list = generateList(num: 716)
// The following prints out: 7 -> 1 -> 6 -> nil
然后我继续使用以下函数反转链表。
第 3 步：反转链表
func reverseLinkedList (head: Node?) -> Node?{
var current = head
var prev: Node?
var next: Node?
while current != nil {
next = current?.next
current?.next = prev
prev = current
current = next
}
return prev
}
let reversedList = reverseLinkedList(head: list)
// The following prints out is: 6 -> 1 -> 7 -> nil
步骤 4：此步骤背后的想法是提取每个节点上的值，将它们转换为字符串，然后将它们连接到字符串变量，最后将字符串值转换为 Int 中，然后使用该 Int 值并最终添加它们。
func getValuesFrom (head: Node?) -> Int {
var string = ""
var current = head
while current != nil {
var stringVal = String(describing: current?.value)
string += stringVal
current = current?.next
}
return Int(string)!
}
这是我遇到问题的地方：
当我像这样将以下内容插入到这个函数中时：
getValuesFrom(head: reversedList)
我收到以下错误：
致命错误：解开可选值时意外发现 nil
而且我似乎无法弄清楚为什么我会遇到问题，并且真的很感激任何形式的见解。
无需在 String 和链表之间来回转换，只需打印它以获得结果。这是简单地完成的，如下所示：
class Node {
var value: Int
var next: Node?
// init and generator can be the same method
init(value: Int) {
// store ones place and divide by 10
self.value = value % 10
var nextValue = value / 10
// set up for loop
var currentNode = self
while nextValue > 0 {
// create a new Node
// store ones place and divide by 10
let next = Node(value: nextValue % 10)
nextValue /= 10
// make the new Node the next Node
currentNode.next = next
// set up for next iteration
currentNode = next
}
}
}
// make the list printable
extension Node: CustomStringConvertible {
var description: String{
if let next = next {
return "(value) -> (next)"
}
else {
return "(value) -> nil"
}
}
}
现在您可以执行以下操作：
print(Node(value: 671)) // prints "7 -> 1 -> 6 -> nil"
鉴于您的问题，也没有必要反转列表。
要对列表求和，您可以按照您所说的方式，转换为Int，添加它们，然后生成一个新列表：
extension Node {
func toValue() -> Int {
var place = 10
var current = self
// add each value and multiply by the place value
// first is 1, second 10, third 100, etc.
var result = current.value
while let next = current.next {
result += next.value * place
place *= 10
current = next
}
return result
}
}
然后你所需要的只是重载加法运算符......
func +(lhs: Node, rhs: Node) -> Node {
return Node(value: lhs.toValue() + rhs.toValue())
}
并测试...
let first = Node(value: 617)
let second = Node(value: 295)
print(first)
print(second)
print(first + second)
结果：
7 -> 1 -> 6 -> 无
5 -> 9 -> 2 -> 无
2 -> 1 -> 9 -> 无