leetcode 21. 合并两个有序链表 go语言实现

递归实现与非递归实现

/**
 * @Description: 链表的遍历
 *
 * @Date:
 * @Author: fuGuoWen
 * @Return
 * @Throws
 */
func Print(l1 *ListNode) {
	for l1 != nil {
		fmt.Println(l1.Val)
		l1 = l1.Next
	}
}

/**
 * @Description: 合并两个有序的链表  非递归实现
 * 时间复杂度O(m+n) 空间复杂度O(1)
 * @Date:
 * @Author: fuGuoWen
 * @Return
 * @Throws
 */
func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
	head := &ListNode{}
	result := head
	for l1 != nil && l2 != nil {
		if l1.Val < l2.Val {
			head.Next = l1
			l1 = l1.Next
		} else {
			head.Next = l2
			l2 = l2.Next
		}
		head = head.Next
	}
	if l1 != nil {
		head.Next = l1
	}

	if l2 != nil {
		head.Next = l2
	}
	return result.Next
}

/**
 * @Description: 合并两个有序的链表  递归实现
 * 时间复杂度O(m+n) 空间复杂度O(1)
 * @Date:
 * @Author: fuGuoWen
 * @Return
 * @Throws
 */
func mergeTwoLists2(l1 *ListNode, l2 *ListNode) *ListNode {

	if l1 == nil {
		return l2
	}
	if l2 == nil {
		return l1
	}

	if l1.Val < l2.Val {
		l1.Next = mergeTwoLists(l1.Next, l2)
		return l1
	} else {
		l2.Next = mergeTwoLists(l1, l2.Next)
		return l2
	}
}

/** 链表的结构 */
type ListNode struct {
	Val  int
	Next *ListNode
}

测试代码

func main() {
	/** 创建链表1 */
	l1 := ListNode{1, nil}
	l2 := ListNode{2, nil}
	l3 := ListNode{4, nil}
	l1.Next = &l2
	l2.Next = &l3
	//打印链表1
	print(&l1)
	fmt.Println("=============")
	/** 常见链表2 */
	l4 := ListNode{1, nil}
	l5 := ListNode{3, nil}
	l6 := ListNode{4, nil}
	l4.Next = &l5
	l5.Next = &l6
	/** 打印链表2 */
	print(&l4)
	fmt.Println("=============")
	/** 合并两个有序的链表 */
	//result := mergeTwoLists(&l1, &l4)
	result := mergeTwoLists2(&l1, &l4)
	print(result)

	//l1 := ListNode{1, nil}
	//l2 := ListNode{2, nil}
	//l3 := ListNode{3, nil}
	//l4 := ListNode{4, nil}
	//l5 := ListNode{5, nil}
	//l1.Next = &l2
	//l2.Next = &l3
	//l3.Next = &l4
	//l4.Next = &l5
	//Print(&l1)
	//fmt.Println("==================")
	result := reverseList(&l1)
	//result := reverseList2(&l1)
	//Print(result)
}