algorithm004-01 · rosela · Dec 15, 2019 · Dec 15, 2019 · Dec 15, 2019 · Dec 15, 2019
diff --git a/Week 07/id_076/LeetCode_146_076.java b/Week 07/id_076/LeetCode_146_076.java
@@ -0,0 +1,95 @@
+import java.util.HashMap;
+
+/**
+ *  LRU 缓存
+ *  1.使用双向链表实现
+ *  2.使用java 自带的 LinkedHashMap 实现
+ *
+ */
+public class LeetCode_146_076 {
+
+    private HashMap<Integer, Node> map;
+    private DoubleList cache;
+    private int cap;
+
+    public LeetCode_146_076(int capacity) {
+        this.cap = capacity;
+        map = new HashMap<>();
+        cache = new DoubleList();
+    }
+
+    public int get(int key) {
+        if (!map.containsKey(key))
+            return -1;
+        int val = map.get(key).val;
+        put(key, val);
+        return val;
+    }
+
+    public void put(int key, int val) {
+        Node x = new Node(key, val);
+
+        if (map.containsKey(key)) {
+            cache.remove(map.get(key));
+            cache.addFirst(x);
+            map.put(key, x);
+        } else {
+            if (cap == cache.size()) {
+                Node last = cache.removeLast();
+                map.remove(last.key);
+            }
+            cache.addFirst(x);
+            map.put(key, x);
+        }
+    }
+
+    class DoubleList {
+        private Node head, tail;
+        private int size;
+
+        public DoubleList() {
+            head = new Node(0, 0);
+            tail = new Node(0, 0);
+            head.next = tail;
+            tail.prev = head;
+            size = 0;
+        }
+
+        public void addFirst(Node x) {
+            x.next = head.next;
+            x.prev = head;
+            head.next.prev = x;
+            head.next = x;
+            size++;
+        }
+
+        public void remove(Node x) {
+            x.prev.next = x.next;
+            x.next.prev = x.prev;
+            size--;
+        }
+
+        public Node removeLast() {
+            if (tail.prev == head)
+                return null;
+            Node last = tail.prev;
+            remove(last);
+            return last;
+        }
+
+        public int size() { return size; }
+
+    }
+
+    class Node {
+        public int key, val;
+        public Node next, prev;
+        public Node(int k, int v) {
+            this.key = k;
+            this.val = v;
+        }
+    }
+}
+
+
+
diff --git a/Week 07/id_076/LeetCode_190_076.java b/Week 07/id_076/LeetCode_190_076.java
@@ -0,0 +1,23 @@
+/**
+ *  颠倒32 位无符号整数的二进制位
+ *
+ */
+public class LeetCode_190_076 {
+
+    public int reverseBits(int n) {
+        int res = 0;
+        for(int i = 0; i < 32; i++) {
+            int cur = n & 1;
+            res += (cur << 31 - i);
+
+            n >>= i;
+        }
+        return res;
+    }
+
+    public static void main(String[] args) {
+        LeetCode_190_076 leetCode = new LeetCode_190_076();
+        int res = leetCode.reverseBits(1);
+        System.out.println(res);
+    }
+}
diff --git a/Week 07/id_076/LeetCode_191_076.java b/Week 07/id_076/LeetCode_191_076.java
@@ -0,0 +1,40 @@
+/**
+ *  1. 循环和位移
+ *     使用 & 操作 ！= 0 确认二进制位是否为1
+ *  2. 消除最后的1
+ *
+ */
+public class LeetCode_191_076 {
+
+    public int hammingWeight(int n) {
+        int size = 0;
+        int mark = 1;
+
+        for(int i = 0; i < 32; i++){
+            if((n & mark) != 0) {
+                size ++;
+            }
+            mark <<= 1;
+        }
+        return size;
+    }
+
+    public int hammingWeight2(int n) {
+        int size = 0;
+        while(n != 0){
+            size ++;
+            n &= (n - 1);
+        }
+        return size;
+    }
+
+    public static void main(String[] args) {
+        LeetCode_191_076 leetCode = new LeetCode_191_076();
+        int size = leetCode.hammingWeight(3);
+        System.out.println(size);
+
+        int size2 = leetCode.hammingWeight2(3);
+        System.out.println(size2);
+
+    }
+}
diff --git a/Week 07/id_076/LeetCode_231_076.java b/Week 07/id_076/LeetCode_231_076.java
@@ -0,0 +1,24 @@
+/**
+ *  判断是否2的幂次方
+ *  2的幂次方， n & (n - 1) == 0
+ */
+public class LeetCode_231_076 {
+
+    public boolean isPowerOfTwo(int n) {
+        if(n <= 0){
+            return false;
+        }
+
+        if((n & (n - 1)) == 0) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public static void main(String[] args) {
+        LeetCode_231_076 leetCode = new LeetCode_231_076();
+        boolean flag = leetCode.isPowerOfTwo(3);
+        System.out.println(flag);
+    }
+}
diff --git a/Week 07/id_076/LeetCode_242_076.java b/Week 07/id_076/LeetCode_242_076.java
@@ -0,0 +1,20 @@
+import java.util.Arrays;
+
+/**
+ *  有效的字母异位词
+ *
+ */
+public class LeetCode_242_076 {
+
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+
+        char[] str1 = s.toCharArray();
+        char[] str2 = t.toCharArray();
+        Arrays.sort(str1);
+        Arrays.sort(str2);
+        return Arrays.equals(str1, str2);
+    }
+}
diff --git a/Week 07/id_076/NOTE.md b/Week 07/id_076/NOTE.md
@@ -1,4 +1,23 @@
 # NOTE
 
-
+学习位运算，布隆过滤器
+对于位运算一直是自己薄弱环节，通过学习初步了解了基本位运算的的初衷及解决那些问题。
+布隆过滤器了解过，但是没有自己实现过，还需进一步学习。
+
+1. 常用位运算操作
+
+乘2：x << 2；
+除2：x >> 2；
+判断一个数是偶数：x & 1；
+将最后一位变成1：x | 1；
+将右数第k为变成1：x | 1 << (k - 1)；
+交换a,b:
+  a ^= b;
+  b ^= a;
+  a ^= b;
+
+判断是2的幂：!(n & (n - 1))；
+消除最末尾的1：x = x & (x - 1);
+对2^n取余：x & (1 << n - 1)；
+
 
diff --git a/Week 08/id_076/LeetCode_300_076.java b/Week 08/id_076/LeetCode_300_076.java
@@ -0,0 +1,27 @@
+/**
+ *  最长上升子序列
+ *  1.暴力解法，采用递归实现
+ *  2.增加递归中间计算缓存
+ *
+ */
+public class LeetCode_300_076 {
+
+    public int lengthOfLIS(int[] nums) {
+        return lengthofLIS(nums, Integer.MIN_VALUE, 0);
+    }
+
+    public int lengthofLIS(int[] nums, int prev, int curpos) {
+        if (curpos == nums.length) {
+            return 0;
+        }
+        int taken = 0;
+        if (nums[curpos] > prev) {
+            taken = 1 + lengthofLIS(nums, nums[curpos], curpos + 1);
+        }
+        int nottaken = lengthofLIS(nums, prev, curpos + 1);
+        return Math.max(taken, nottaken);
+    }
+}
+
+
+
diff --git a/Week 08/id_076/LeetCode_541_076.java b/Week 08/id_076/LeetCode_541_076.java
@@ -0,0 +1,39 @@
+/**
+ * 翻转字符串
+ *
+ */
+public class LeetCode_541_076 {
+
+    public String reverseStr(String s, int k) {
+        char[] s_arr = s.toCharArray();
+
+        for(int i = 0;i < s_arr.length;){
+            //反转k
+            if(i + k >= s_arr.length){
+                reverseArr(s_arr,i,s_arr.length - 1);
+                break;
+            }else{
+                reverseArr(s_arr,i,i + k-1);
+            }
+            i += k;
+
+            //跳过k
+            if(i + k >= s_arr.length){
+                break;
+            }
+            i += k;
+        }
+        return String.valueOf(s_arr);
+    }
+
+    public void reverseArr(char[] arr , int from , int end){
+        for(int i = from , j = end; i < j;i++ , j--){
+            char t = arr[i];
+            arr[i] = arr[j];
+            arr[j] = t;
+        }
+    }
+}
+
+
+
diff --git a/Week 08/id_076/NOTE.md b/Week 08/id_076/NOTE.md
@@ -0,0 +1 @@
+