技術標籤：leetcode演算法

第23題：合併K個升序連結串列

這題成績極其的差，看了題解的方案後發現好像也沒有什麼區別嘿，都是O(kn)，可為啥~~

lists直接取值：

func mergeKLists(lists []*ListNode) *ListNode {
    min := 10000 + 1
    n := 0
    for i, j := range lists{
        if j == nil {continue}
        if j.Val < min {
            min = j.Val
            n = i
        }
 

    }
    if min == 10000 + 1{return nil}
    node := lists[n]
    if lists[n] != nil {lists[n] = lists[n].Next}
    node.Next = mergeKLists(lists)
    return node
}

裝陣列取值：

func mergeKLists(lists []*ListNode) *ListNode {
    if len(lists) == 0{return nil}
	var m []int
	for _,j := range lists{
		if j !=
 
 nil {
            m = append(m, j.Val)
        }else{
            m = append(m, 10000+1)
        }
	}
	return f(m,lists)
}

func f(n []int, lists []*ListNode) *ListNode{
	min := 10000 + 1
	m := 0
	for i,j := range n {
		if j < min {
			min = j
			m = i
		}
	}
    if min == 10000 + 1{return nil}
    node := lists[
 
m]
	if node != nil && node.Next != nil {
		n[m] = node.Next.Val
        lists[m] = node.Next
	}else{
		n[m] = 10000 + 1
	}
	if node != nil {node.Next = f(n,lists)}
	return node
}

第26題：刪除排序陣列中的重複項

這題也是一道簡單題，思路很重要：因為是排序好的陣列，所以如果有重複值都是緊挨著的，只要儲存與上一位不同的值即可

func removeDuplicates(nums []int) int {
	j := 0
	for _,i := range nums {
		if nums[j] != i{
			j++
			nums[j] = i
		}
	}
	return j+1
}

第33題：搜尋旋轉排序陣列

好吧，這題直接暴力成績也不錯，因為差別確實不大，比較一下第一個值和target就可以確定要從哪邊開始遍歷。

func search(nums []int, target int) int {
    if len(nums) < 1{return -1}
    if target < nums[0]{
        for k := len(nums) - 1; k > 0; k--{
                if nums[k] == target{return k}
        }
    }else{
        for i, j := range nums{
            if j == target{return i}
        }
    }
    return -1
}