万物的算法日记|第五天

笔者自述：

一直有一个声音也一直能听到身边的大佬经常说，要把算法学习搞好，一定要重视平时的算法学习，虽然每天也在学算法，但是感觉自己一直在假装努力表面功夫骗了自己，没有规划好自己的算法学习和总结，因为后半年也该找实习了，所以每日的算法题要进行恶补，勤能补拙，因此有了这一个算法日记系列；

必读： 大佬你好，感谢您的阅读，这篇文章是我的算法笔记，方便我每日回顾；
为了不耽误您的时间，我把本篇日记的考点方向和算法知识总结列出来，如果对您有需要就进行向下阅读
也希望对您有帮助，和您一起通关算法！致谢

算法语言：java
题目来源：力扣–书本–初级算法，可以在力扣中搜索相关题名找到更多解法和大神方法
本文知识点：

1. 使用java中自带的方法去解题

.使用字符串自带的s.indexOf() 和 s.lastIndexOf()可以查到字符出现的第一次位置和最后一次位置，相同的话就说明只出现了一次

2. 广度优先搜若BFS

什么是广搜？ BFS是二叉树，图等数据结构中的遍历算法的一种，思想是从起始点开始，逐层向外扩展，访问尽可能多的节点。
实现方法： 使用队列来保存每一层的节点，按照队列先进先出的原则，一次访问每个节点，并将其未访问过的相邻的节点加入队列中，保证先访问距离起始点近的节点的同时，逐层访问整张图，直到遍历完所有的节点
特点： 适用于无权图或者所有边权相等的图‘；能够搜到的最短路径就是从起点到目标状态的最短路径，同时可以解决最短路径问题；
适用场景：寻找最短路径以及需要遍历全部节点时
方法： isEmpty() poll() 取出队头元素 add() 向队尾添加元素

Queue queue = new LinkedList<>(){ { add(root); }};此处使用了java中的双括号初始化特征

TreeNode 初始化要会写

class TreeNode{
    
    
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x){
    
    
        this.val = x;
    }
}

3. 队列的简单使用 ，通过对二叉树的三次变形打印练习，对队列的掌握程度会逐步提高。.

详细可针对具体题目具体分析~~

剑指 Offer 50. 第一个只出现一次的字符

代码：

//第一种方法：暴力解法
    public char firstUniqChar(String s){
    
    
        char[] c = s.toCharArray(); //将字符串转化为数组
        for(int i =0;i<c.length;i++){
    
    
            boolean res = true;
            for(int j=0;j<c.length;j++){
    
    
                 if(j == i){
    
    
                     continue;
                 }
                 if(c[i] == c[j]){
    
    
                     res= false;
                     break;
                 }
            }
            if(res){
    
    
                return c[i];
            }
        }
        return ' ';
    }
    //第二种方法：内置库法
    public char firstUniqChar1(String s){
    
    
        for(int i =0;i<s.length();i++){
    
    
            if(s.indexOf(s.charAt(i)) == s.lastIndexOf(s.charAt(i))){
    
    
                return s.charAt(i);
            }
        }
        return ' ';
    }
    //第三种方法：使用hashmap来解决
    public char firstUniqChar2(String s){
    
    
        if(s == null || s.length() == 0){
    
    
            return ' ';
        }
        Map<Character,Integer> map = new HashMap<>();
        for(int i =0;i<s.length();i++){
    
    
            char c = s.charAt(i);
            map.put(c,map.getOrDefault(c,0)+1);
        }
        for(int i =0;i<s.length();i++){
    
    
            char c = s.charAt(i);
            if(map.get(c) == 1){
    
    
                return c;
            }
        }
        return ' ';
    }

学到的知识：

1. 这道题我拿到之后，首先想到的是使用hashmap来解决，但是因为hashmap是无序的，我错误的去遍历键来获取值，导致最后拿到的不是题中要求的 ”第一个“,经过修改应该用字符去找对应的键核对值，像方法三那样的
2. 可以使用字符串自带的s.indexOf() 和 s.lastIndexOf()可以查到字符出现的第一次位置和最后一次位置，相同的话就说明只出现了一次

剑指 Offer 32 - I. 从上到下打印二叉树

代码：

public int[] levelOrder(TreeNode root){
    
    
        //按层遍历 同时可以成为 BFS  BFS 通常借助队列的先进先出的特征来实现
        if(root == null)
            return new int[0];
        Queue<TreeNode> queue = new LinkedList<>(){
    
    {
    
     add(root); }};
        ArrayList<Integer> ans = new ArrayList<>();
        while(!queue.isEmpty()){
    
    
            TreeNode node = queue.poll();
            ans.add(node.val);
            if(node.left != null) queue.add(node.left);
            if(node.right != null) queue.add(node.right);
        }
        int[] res= new int[ans.size()];
        for(int i =0;i<ans.size();i++){
    
    
            res[i] = ans.get(i);
        }
        return res;

    }

学到的知识点：

1. 对于二叉树，层次遍历的话就相当于使用BFS(广度优先搜索),对于BFS通常用队列来实现

什么是广搜？ BFS是二叉树，图等数据结构中的遍历算法的一种，思想是从起始点开始，逐层向外扩展，访问尽可能多的节点。
实现方法： 使用队列来保存每一层的节点，按照队列先进先出的原则，一次访问每个节点，并将其未访问过的相邻的节点加入队列中，保证先访问距离起始点近的节点的同时，逐层访问整张图，直到遍历完所有的节点
特点： 适用于无权图或者所有边权相等的图‘；能够搜到的最短路径就是从起点到目标状态的最短路径，同时可以解决最短路径问题；
适用场景：寻找最短路径以及需要遍历全部节点时
方法： isEmpty() poll() 取出队头元素 add() 向队尾添加元素

2. Queue queue = new LinkedList<>(){ { add(root); }};此处使用了java中的双括号初始化特征
3. TreeNode 初始化要会写

class TreeNode{
    
    
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x){
    
    
        this.val = x;
    }
}

剑指 Offer 32 - II. 从上到下打印二叉树 II

代码：

public List<List<Integer>> levelOrder(TreeNode root){
    
    
        List<List<Integer>> list1 = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if(root  != null){
    
    
            queue.add(root);
        }
        while(!queue.isEmpty() ){
    
    
            List<Integer> list = new ArrayList<>();
            for(int i = queue.size();i>0;i--) {
    
    
                TreeNode tree = queue.poll();
                list.add(tree.val);
                if (tree.left != null) queue.add(tree.left);
                if (tree.right != null) queue.add(tree.right);
            }
            list1.add(list);
        }
        return list1;
    }

学到的知识：

1. 为什么队列使用LinkedList 而不使用ArrayLIst 创建，因为LinkedLIst实现了队列的接口，而ArrayList实现了LIst接口，所以在创建队列的时候，一般使用LinkedLIst
2. 同时LinkedList是一个链式数据结构，他每个元素都包含一个指向前一个元素和后一个元素的指针，这种类型更适合队列的底层实现，同时时间复杂度也非常的低。
3. 本题相对于上一个二叉树遍历，多的是将每一层都加进到一个列表中，基础原理还是一样的。

剑指 Offer 32 - III. 从上到下打印二叉树 III

代码：

public List<List<Integer>> levelOrder(TreeNode root){
    
    
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) queue.add(root);
        while(! queue.isEmpty()){
    
    
            LinkedList<Integer> list = new LinkedList<>();
            for(int i =queue.size();i>0;i--){
    
    
                TreeNode tree = queue.poll();
                if(res.size() % 2 == 0) list.addLast(tree.val);
                else list.addFirst(tree.val);
                if(tree.left != null) queue.add(tree.left);
                if(tree.right != null) queue.add(tree.right);
            }
            res.add(list);
        }
        return res;
    }

学到的知识：

1. 链表的定义其实有三种，一种是LIst，表示可自由切换成LInkedList 和 ArrayList，剩余两种是Arraylist和LinkedList，
2. 这道题相对于前两个难点在于z字形打印，其实只需要判断总链表中的元素所在的位置通过奇偶位，分别在队列尾部和头部添加元素 ，就可以实现z字形打印，
3. 其中需要使用LInkedLIst明确是该链表结构才可以使用addLast和addFirst方法