第一题

题目

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

如：

输入： n = 19

输出： true

解释：

12 + 92 = 82

82 + 22 = 68

62 + 82 = 100

12 + 02 + 02 = 1

思路

1、给的数是1，就是快乐数

2、一系列操作之后，能够得到1

3、一系列操作之后，不能得到1，造成死循环

所以怎么判定死循环，只要定义一个list，只要算出来一个数，扔进去一个数，如果算出来的数在list里面已经有了，就game over吧！

至于算数的过程，我记得我之前写过那个各个位数的乘积和和的那道题，一个思路，不再复述

真要注意一点，函数变得复杂的时候，能拆开写尽量拆开写，不然不小心就出错，真讨厌！

代码

    public boolean isHappy(int n) {
        if(n == 1) return true;
        List list = new ArrayList();
        while(n != 1 && !list.contains(n)) {
            list.add(n);
            n = getNext(n);
        }
        return n==1;
    }
    private int getNext(int n) {
        int res = 0;
        while(n > 0) {
            int num = n % 10;
            n = n/10;
            res+= num * num;
        }
        return res;
    }

第二题

题目

给你长度相等的两个字符串 s1 和 s2 。一次 字符串交换 操作的步骤如下：选出某个字符串中的两个下标（不必不同），并交换这两个下标所对应的字符。

如果对 其中一个字符串 执行 最多一次字符串交换 就可以使两个字符串相等，返回 true ；否则，返回 false 。

思路

1、先判定两个字符串是不是直接相等，注意用equals

2、要是有2个以上的索引上的元素不相等，说明已经不符合题意了，直接false

3、正好两个索引，也要判断交换是否相等

代码

    public boolean areAlmostEqual(String s1, String s2) {
        if(s1.equals(s2)) return true;
        int index = -1;
        int num = 0;
        boolean res = false;
        for(int i = 0; i < s1.length(); i++) {
            if(s1.charAt(i) != s2.charAt(i)) {
                num++;
                if(index == -1) {
                    index = i;
                }else {
                    if(num > 2) {
                            res = false;
                            break;
                    };
                    if(num == 2 &&
                    s1.charAt(index) == s2.charAt(i) &&
                    s1.charAt(i) == s2.charAt(index)) {
                        res = true;
                    };
                }
            };
        };
        return res;
    }

第三题

题目

给定一个 n 叉树的根节点  root ，返回 其节点值的 前序遍历 。

n 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔

思路

啊～多练一下

有点思路但是写起来很乱，还是因为好久没碰树了，手忙脑子乱

主要总结下来就是，使用递归，每次递归先访问根节点，然后依次递归访问每个孩子节点就可以了

代码

/*
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<Integer> preorder(Node root) {
        List<Integer> list = new ArrayList<Integer>();
        helper(root, list);
        return list;
    }

    public void helper(Node root, List<Integer> res) {
        if (root == null) {
            return;
        }
        res.add(root.val);
        for (Node ch : root.children) {
            helper(ch, res);
        }
    }
}