面试算法题笔记

一、数组

448. 找到所有数组中消失的数字

题目：leetcode 448

思路：

1. 由于value范围是1~n，数组nums长度也是n。
2. 第一次遍历，以(value-1)%n作为下标（下标范围0~n-1），将nums[value] += n。
3. 这样可以保证（出现过的数字-1）的下标内的value都大于n。
4. 第二次遍历，所有value小于n的下标就是答案。

func findDisappearedNumbers(nums []int) []int {
     
    n := len(nums)
    for _, v := range nums {
     
        v = (v - 1) % n // 取模防止v越界
        nums[v] += n
    }

    ans := []int{
     }
    for i, v := range nums {
     
        if v <= n {
     
            ans = append(ans, i + 1)
        }
    }
    return ans
}

二、 树

114. 二叉树展开为链表

题目：leetcode 114

思路：

1. 如果有左孩子，则找到左孩子所在的子树最右侧的节点p。
2. 让p的右指针指向当前节点的右孩子，且当前节点的左孩子置为nil，遍历下一个节点（右孩子）。
3. 如果没有左孩子，就遍历下一个节点（右孩子）。
4. 直到所有节点遍历完成。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func flatten(root *TreeNode)  {
     
    cur := root
    for cur != nil {
     
        tail := cur.Left
        if tail != nil {
     
            for tail.Right != nil {
     
                tail = tail.Right
            }
            tail.Right = cur.Right
            cur.Right = cur.Left
            cur.Left = nil
        }
        cur = cur.Right
    }
}

102. 二叉树的层序遍历

题目：leetcode 102

思路：利用队列，按层遍历

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
     
    ret := [][]int{
     }
    if root == nil {
     
        return ret
    }
    queue := []*TreeNode{
     root}
    for i := 0; len(queue) > 0; i++ {
     
        ret = append(ret, []int{
     })
        q := queue
        queue = nil
        for _, node := range q {
     
            ret[i] = append(ret[i], node.Val)
            if node.Left != nil {
     
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
     
                queue = append(queue, node.Right)
            }
        }
        // 可以对当前层反转，如leetcode 103 锯齿遍历
    }
    return ret
}

105. 从前序与中序遍历序列构造二叉树

题目：leetcode 105

思路：利用递归，每次将能构成一棵子树的preOrder子数组和inOrder子数组传入函数。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func buildTree(preorder []int, inorder []int) *TreeNode {
     
    var helper func (pre []int, in []int) *TreeNode
    helper = func (pre []int, in []int) *TreeNode {
     
        if len(pre) == 0 {
     
            return nil
        }
        root := &TreeNode{
     pre[0], nil, nil}
        index := 0
        for ; ; index++ {
     
            if in[index] == root.Val {
     
                break
            }
        }
        root.Left = helper(pre[1: 1 + index], in[: index])
        root.Right = helper(pre[1 + index: ], in[1 + index:])
        return root
    }
    return helper(preorder, inorder)
}