[算法]写算法时候需要记住的小技巧

1. 对于字符串可以使用toArray() 

2. 字符串相加中：

    public String addStrings(String num1, String num2) {
        StringBuilder res = new StringBuilder("");
        int i = num1.length() - 1, j = num2.length() - 1, carry = 0;
        while(i >= 0 || j >= 0){
            //这边有一个认知，可以直接用
            int n1 = i >= 0 ? num1.charAt(i) - '0' : 0;
            int n2 = j >= 0 ? num2.charAt(j) - '0' : 0;
            int tmp = n1 + n2 + carry;
            carry = tmp / 10;
            res.append(tmp % 10);
            i--; j--;
        }
        //carry常用来标识进位，用来表示最后一位还有进位吗
        if(carry == 1) res.append(1);
        //最后做一个字符串的翻转
        return res.reverse().toString();
    }

记住num1.charAt(i)这个代表的是某一个位置的char

char数字类型可以直接用符号位做运算

carry常用来做进位的计数

3.某些情况下可以直接用str.reverse()做字符串翻转

4. 声明队列Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(u); //添加元素

        q.poll(); //拿出元素
5. Map.getOrDefault() 可以有就返回，没有就返回默认值

getOrDefault(key, -1)

6. 双向链表的结构定义：

    class DLinkedNode {
        int key;
        int value;
        DLinkedNode prev;
        DLinkedNode next;
        public DLinkedNode() {}
        public DLinkedNode(int _key, int _value) {key = _key; value = _value;}
    }

7. 滑动窗口要控制左边和右边，还有总和。

8.java的直接int接受的比如 5/2，是多少，其实是2.

因为直接用int接受的是向下取整。

java中除法：

        double a = 5/2;
        double b = 5.0/2;
        double c = 5.0/2.0;
        System.out.println(a + "``````````````" + b + "````````" + c);

输出结果：2.0``````````````2.5````````2.5

9. 

舍掉小数取整:Math.floor(3.5)=3  （向下取整）

四舍五入取整:Math.rint(3.5)=4

进位取整:Math.ceil(3.1)=4   （向上取整）

取绝对值：Math.abs(-3.5)=3.5

取余数：A%B = 余数 

Math.Max  :

public static int max(int a, int b) {
    return (a >= b) ? a : b;
}

还有min方法

10. 数组转List

List<String> list = Arrays.asList(array);

但是int类型的话：

需要使用Integer

Integer[] array = list.toArray(new Integer[list.size()]);//能正确运行

使用流处理也可以~

List<Integer> list = new ArrayList<>();
return list.stream().mapToInt(Integer::valueOf).toArray();

11. 栈的使用：

Stack<ListNode> stack = new Stack<ListNode>();

stackpush(temp);

stack.pop()

大小是stack.size()

12. 树的深度是左子树深度或右子树深度最大值+1

    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }

13. 对二维数组进行升序操作

Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

14. 对数组先克隆 然后排序

适用于https://leetcode-cn.com/problems/sub-sort-lcci/ 部分排序。

int[] sorted = array.clone();
Arrays.sort(sorted);

至于这个排序用的是什么排序：

https://www.cnblogs.com/baichunyu/p/11935995.html

15. 求余运算规则

设正整数 x, y, px,y,p ，求余符号为 ⊙ ，则有 (x + y) ⊙ p = (x ⊙ p + y ⊙ p) ⊙ p

16.List<Integer> 转 int

List<Integer> result = new ArrayList<Integer>();

return result.stream().mapToInt(Integer::valueOf).toArray();

17.使用queue

注意声明：

Queue<TreeNode> queue = new LinkedList<TreeNode>();

然后注意：放入元素

queue.offer(root);

拿出元素：

TreeNode node = queue.poll();

18. 数学函数 Math.min(a,b)；

19. new String(arr) 来返回一个字符串，把数组进行返回；

20. 注意List弄成String[]

 List<String> res = new LinkedList<>();
    char[] c;
    public String[] permutation(String s) {
        c = s.toCharArray();
        dfs(0);
        return res.toArray(new String[res.size()]);
    }

21. map的遍历方式

        int maxTimes = 0;    // 出现最多的元素的出现次数
        // 找出出现次数最多的元素出现的次数
        for(Map.Entry<Integer, Integer> entry : map.entrySet()){
            if(entry.getValue() > maxTimes){
                maxTimes = entry.getValue();
            }
        }

22. 等价map.get

if(map.containsKey(num)){

map.put(num, map.get(num) + 1);

}else{

map.put(num, 1);

}