算法训练第二周

哈希表、映射、集合、树、二叉树、堆

Leetcode-1(两数之和)

class Solution {
    public int[] twoSum(int[] nums, int target) {
       Map<Integer,Integer> hashtable=new HashMap<Integer,Integer>();
       for(int i=0;i<nums.length;i++){
       //边循环边查找是否存在符合条件值的小标
           if(hashtable.containsKey(target-nums[i])){
               return new int[]{hashtable.get(target-nums[i],i)};
           }
           hashtable.put(nums[i],i);
       }
       return new int[0];
    }
}

二叉树的前序遍历

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        LinkedList <TreeNode> stack=new LinkedList<>();
        LinkedList <Integer>  output=new LinkedList<>();

        if(root==null){
            return output;
        }

        stack.add(root);
        while(!stack.isEmpty()){
            TreeNode node=stack.pollLast();
            output.add(node.val);

            if(node.right!=null){
                stack.add(node.right);
            }
            if(node.left!=null){
                stack.add(node.left);
            }
        }

  return  output;
     }
}

有效的字母异位词

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length())
            return false;
        int[] a=new int [26];
        for(int i=0;i<s.length();i++){
            a[s.charAt(i)-'a']++;//.charAt获取对应索引的字符
            a[t.charAt(i)-'a']--;

        }
        for(int i=0;i<26;i++)
            if(a[i]!=0)
                return false;
            return true;
        

    }
}

字母异位词分组

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        if(strs.length==0) return new ArrayList();
        Map<String,List> ans=new HashMap<String,List>();
        for(String s:strs){
            char[] ca=s.toCharArray();//toCharArray() 方法将字符串转换为字符数组
            Arrays.sort(ca);          
            String key=String.valueOf(ca);//将 char 数组 data 转换成字符串 
            if(!ans.containsKey(key)) ans.put(key,new ArrayList());
            ans.get(key).add(s);
        }
        return new ArrayList(ans.values());
    }
}

二叉树的前序遍历

//1.递归解法
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<Integer>();
        preorder(root,res);
        return res;

        
    }
    public void preorder(TreeNode root,List<Integer> res){
        if(root==null){
            return;
        }
        res.add(root.val);//根
        preorder(root.left,res);//左
        preorder(root.right,res);//右
    }
}
//2.迭代
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<Integer>();
        if(root==null){
            return res;
        }
        Deque<TreeNode> stack=new LinkedList<TreeNode>();
        TreeNode node=root;
        while(!stack.isEmpty()||node!=null){
            while(node!=null){
                res.add(node.val);
                stack.push(node);
                node=node.left;
            }
            node=stack.pop();
            node=node.right;
        }
        return res;
        
    }
}

第二周学习总结：第二周恰逢国庆中秋时期，学习时间被懒散的自己给挤压掉了，于是乎匆匆忙忙之中追赶补上。
第二周学习哈希表、树、堆等知识点。
LeetCode-1两数之和(哈希表、映射)：第一种解法为暴力求解，两次循环找出符合题目值的下标然后返回。第二种解法为利用哈希表的映射只需循环一次，一边存储映射一边寻找符合题目条件的值，nums[i]为哈希表映射的键 i(下标)为映射的值。
LeetCode-144二叉树的前序遍历(树和递归的运用):手动创建两个栈(stack&output)，stack 前序遍历为：根左右
用于存储树。output用于输出题解数组。
1.递归终止条件：当节点为null，返回输出栈
2.实现，当输入的树不为空，运用stack.pollLast()//检索并删除此列表的第一个元素，如果此列表为空，则返回null。然后依次压入右子树 左子树（栈中先进后出）
个人总结：
本周学习十分差劲，感觉收获没有第一周多，并且刷题质量以及数量也有所下降，现在有点迷茫，感觉自己看似学习了，但是好像还是做不出什么题目，而且也没有太多反馈。
java库函数不熟悉，很多题目直接出现的函数不知道其意思。