面试算法题笔记

面试算法题笔记

  • 一、数组
    • 448. 找到所有数组中消失的数字
  • 二、 树
    • 114. 二叉树展开为链表
      • 102. 二叉树的层序遍历
      • 105. 从前序与中序遍历序列构造二叉树

一、数组

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

你可能感兴趣的:(面试,算法)