| by suyi | No comments

Go学习笔记2

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

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
	}
}

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

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 。

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
}

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

/**
 * 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
}

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

/**
 * 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)
}

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

/**
 * 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
    }
}

发表评论