Lingkang的算法学习日记4之链表归并二分排序

归并二分法排序

type ListNode struct {
	Val  int
	Next *ListNode
}

func main() {
	testNode := &ListNode{
		Val:  4,
		Next: nil,
	}
	testNode.Next = &ListNode{
		Val:  2,
		Next: nil,
	}
	testNode.Next.Next = &ListNode{
		Val:  1,
		Next: nil,
	}
	testNode.Next.Next.Next = &ListNode{
		Val:  3,
		Next: nil,
	}
	ans := sortList(testNode)
	for {
		if ans == nil {
			return
		}
		fmt.Println(ans.Val)
		ans = ans.Next

	}
}

func sortList(head *ListNode) *ListNode {
	if head == nil || head.Next == nil {
		return head
	}

	middle := findMiddle(head)
	left := head
	right := middle.Next
	middle.Next = nil

	return merge(sortList(left), sortList(right))
}

func findMiddle(head *ListNode) *ListNode {
	slow, fast := head, head

	for fast != nil && fast.Next != nil && fast.Next.Next != nil {
		slow = slow.Next
		fast = fast.Next.Next
	}

	return slow
}

func merge(left, right *ListNode) *ListNode {
	dummy := &ListNode{}
	curr := dummy

	for left != nil && right != nil {
		if left.Val < right.Val {
			curr.Next = left
			left = left.Next
		} else {
			curr.Next = right
			right = right.Next
		}
		curr = curr.Next
	}

	if left != nil {
		curr.Next = left
	}
	if right != nil {
		curr.Next = right
	}

	return dummy.Next
}

核心思想：

将每个node指向next全部断掉，以递归的方式两个两个组合，组合的时候对左右两个list排序，实现排序，当全部断连接，实际内存中会存每个node的值，再以此组合。

可以画递归树看逻辑