从零开始的力扣刷题记录-第四十一天

653. 两数之和 IV - 输入二叉搜索树-简单

题目描述：
给定一个二叉搜索树 root 和一个目标结果 k，如果二叉搜索树中存在两个元素且它们的和等于给定的目标结果，则返回 true

题解：
中序遍历加双指针

代码（Go）：

func findTarget(root *TreeNode, k int) bool {
    sce := []int{}
    var search func(root *TreeNode)
    search = func(root *TreeNode){
        if root == nil{
            return
        }
        search(root.Left)
        sce = append(sce,root.Val)
        search(root.Right)
    }
    search(root)
    p,q := 0,len(sce) - 1
    for p < q{
        if sce[p] + sce[q] == k{
            return true
        }else if sce[p] + sce[q] > k{
            q--
        }else if sce[p] + sce[q] 

671. 二叉树中第二小的节点-简单

题目描述：
给定一个非空特殊的二叉树，每个节点都是正数，并且每个节点的子节点数量只能为 2 或 0。如果一个节点有两个子节点的话，那么该节点的值等于两个子节点中较小的一个。
更正式地说，即 root.val = min(root.left.val, root.right.val) 总成立。
给出这样的一个二叉树，你需要输出所有节点中的 第二小的值 。
如果第二小的值不存在的话，输出 -1 。

题解：
递归遍历树，如果节点值大于根节点值就可以存下来剪枝了，最后遍历所有存下来的节点，找到最小值。写完才发现不用全部存下来，直接用一个变量随时更新找到的最小值就可以了

代码（Go）：

func findSecondMinimumValue(root *TreeNode) int {
    sce := []int{}
    k := root.Val
    var search func(root *TreeNode,k int)
    search = func(root *TreeNode,k int){
        if root.Left != nil{
            if root.Left.Val > k{
                sce = append(sce,root.Left.Val)
            }else{
                search(root.Left,k)
            }
        }
        if root.Right != nil{
            if root.Right.Val > k{
                sce = append(sce,root.Right.Val)
            }else{
                search(root.Right,k)
            }
        }
    }
    search(root,k)
    if len(sce) == 0{
        return -1
    }
    temp := sce[0]
    for _,v := range sce{
        if v < temp{
            temp = v
        }
    }
    return temp
}

819. 最常见的单词-简单

题目描述：
给定一个段落 (paragraph) 和一个禁用单词列表 (banned)。返回出现次数最多，同时不在禁用列表中的单词。
题目保证至少有一个词不在禁用列表中，而且答案唯一。
禁用列表中的单词用小写字母表示，不含标点符号。段落中的单词不区分大小写。答案都是小写字母。

题解：
哈希表，遍历段落将单词加入哈希表统计数量，再遍历禁用词列表把哈希表中对应单词的数量改为0，最后遍历哈希表找出出现次数最多的单词

代码（Go）：

func mostCommonWord(paragraph string, banned []string) string {
    low := strings.ToLower(paragraph)
    p,q := 0,0
    dict := map[string]int{}
    for q < len(low){
        for low[p] < 'a' || low[p] > 'z'{
            p++
            q++
            if p == len(low){
                break
            }
        }
        if p == len(low){
            break
        }
        if low[q] >= 'a' && low[q] <= 'z'{
            q++
            if q == len(low){
                temp := low[p:q]
                if _,ok := dict[temp];ok{
                    dict[temp]++
                }else{
                    dict[temp] = 1
                }
                break
            }
        }else{
            temp := low[p:q]
            if _,ok := dict[temp];ok{
                dict[temp]++
            }else{
                dict[temp] = 1
            }
            p = q
        }
    }
    for _,v := range banned{
        if _,ok := dict[v];ok{
            dict[v] = 0
        }
    }
    var temp string
    num := 0
    for i,v := range dict{
        if v > num{
            num = v
            temp = i
        }
    }
    return temp
}

24. 两两交换链表中的节点-中等

题目描述：
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）

题解：
新建立一个不保存数值的头节点指向链表头节点，然后就是正常的for循环交换节点

代码（Go）：

func swapPairs(head *ListNode) *ListNode {
    tempHead := &ListNode{0, head}
    temp := tempHead
    for temp.Next != nil && temp.Next.Next != nil {
        p := temp.Next
        q := temp.Next.Next
        temp.Next = q
        p.Next = q.Next
        q.Next = p
        temp = p
    }
    return tempHead.Next
}

总结

又是被回溯折磨的一天，最后还是没做出来，找了一道简单点的题，感觉需要补补基础知识