Go学习笔记2

给定一副牌，每张牌上都写着一个整数。此时，你需要选定一个数字 X，使我们可以将整副牌按下述规则分成 1 组或更多组：每组都有 X 张牌；组内所有的牌上都写着相同的整数；仅当你可选的 X >= 2 时返回 true 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
func hasGroupsSizeX(deck []int) bool {
if len(deck) == 1  len(deck) == 0 {return false}
deckMap := make(map[int]int)
for i := 0; i < len(deck); i++ {
deckMap[deck[i]] ++
}

min := deckMap[deck[0]]
for _, v := range deckMap {
gcd := gcd(v, min)
if gcd < min && gcd != 1{
min = gcd
}
}

for _, v := range deckMap {
if v == 1 { return false}
if v != min {
if v % min != 0 {
return false
}
}
}

return true
}

func gcd(x, y int) int {
tmp := x % y
if tmp > 0 {
return gcd(y, tmp)
} else {
return y
}
}

给你一个二叉树，请你返回其按 层序遍历 得到的节点值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var result [][]int
func levelOrder(root *TreeNode) [][]int {
result = make([][]int, 0)
if root == nil {
return result
}
dfsHelper(root, 0)
return result
}

func dfsHelper(node *TreeNode, level int) {
if node == nil {
return
}
if len(result) < level+1 {
result = append(result, make([]int, 0))
}
result[level] = append(result[level], node.Val)
dfsHelper(node.Left, level+1)
dfsHelper(node.Right, level+1)
}

给你一个由若干 0 和 1 组成的数组 nums 以及整数 k。如果所有 1 都至少相隔 k 个元素，则返回 True ；否则，返回 False 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func kLengthApart(nums []int, k int) bool {
indexL := make([]int, 0)

for index, value := range nums {
if value == 1{
indexL = append(indexL, index)
}
}
fmt.Println("indexL:", indexL)

if len(indexL) == 1 && len(indexL) == 0 {return true}

for i := 0; i < len(indexL) - 1; i++ {
if indexL[i + 1] - indexL[i] - 1 < k {
return false
}
}
return true
}

编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeDuplicateNodes(head *ListNode) *ListNode {
    nums := make(map[int]int)
    res := new(ListNode)
    p := res
    for head != nil {
        if nums[head.Val] == 0 {
            p.Next = head
            p = head
        } else {
            p.Next = head.Next
        }

        nums[head.Val] ++
        head = head.Next
    }

    return res.Next
}

给定一个二叉树，判断它是否是高度平衡的二叉树。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isBalanced(root *TreeNode) bool {
    if root == nil {return true}
    return convertToBool(root, root)
}

func convertToBool(root1 *TreeNode, root2 *TreeNode) bool{
    if root1 == nil && root2 == nil {
        return true
    }

    if root1 == nil && root2.Left == nil && root2.Right == nil {
        return true
    }

    if root2 == nil && root1.Right == nil && root1.Left == nil {
        return true
    }

    return convertToBool(root1.Left, root2.Right) && convertToBool(root2.Left, root1.Right)
}

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeTwoLists(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
    }
}