添加lru测试实例

dyh · dyh · commit 7f5aa21e2b12 · 2024-12-08T12:20:22.000+08:00
diff --git a/java/java_test/src/cache/LruCacheTest1.java b/java/java_test/src/cache/LruCacheTest1.java
@@ -0,0 +1,37 @@
+package cache;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/12/8 12:09
+ * @description
+ */
+public class LruCacheTest1 {
+    public static void main(String[] args) {
+        LruCacheWithExpiration cache = new LruCacheWithExpiration(5, 3000);
+        cache.put("key1", "value1");
+        cache.put("key2", "value2");
+        cache.put("key3", "value3");
+        System.out.println("获取key2的值: " + cache.get("key2"));
+
+        // 模拟等待4秒，让部分数据过期
+        try {
+            Thread.sleep(4000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        // 验证过期后获取不存在的键
+        System.out.println("获取key1的值: " + cache.get("key1"));
+
+        // 再次放入新键值对，触发LRU淘汰和过期清理
+        cache.put("key6", "value6");
+
+          // 验证被淘汰的键不存在
+        System.out.println("获取key3的值: " + cache.get("key3"));
+
+        // 验证新放入的键能获取到
+        System.out.println("获取key6的值: " + cache.get("key6"));
+
+    }
+}
diff --git a/java/java_test/src/cache/LruCacheTest2.java b/java/java_test/src/cache/LruCacheTest2.java
@@ -0,0 +1,32 @@
+package cache;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/12/8 12:15
+ * @description
+ */
+public class LruCacheTest2 {
+    public static void main(String[] args) {
+         LruCacheWithExpiration cache = new LruCacheWithExpiration(4, 5000);
+
+        cache.put("key1", "value1");
+        cache.put("key2", "value2");
+        cache.put("key3", "value3");
+        cache.put("key4", "value4");
+
+        // 多次获取key2，使其成为最近使用的元素
+        for (int i = 0; i < 3; i++) {
+            System.out.println("第" + (i + 1) + "次获取key2的值: " + cache.get("key2"));
+        }
+
+         cache.put("key5", "value5");
+
+        // 验证key2因频繁被获取而未被淘汰，仍能获取到
+        System.out.println("获取key2的值: " + cache.get("key2"));
+
+        // 验证最早放入且少被使用的元素（比如key1）被淘汰了
+        System.out.println("获取key1的值: " + cache.get("key1"));
+
+    }
+}
diff --git a/java/java_test/src/cache/LruCacheTest3.java b/java/java_test/src/cache/LruCacheTest3.java
@@ -0,0 +1,43 @@
+package cache;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/12/8 12:15
+ * @description
+ */
+public class LruCacheTest3 {
+    public static void main(String[] args) {
+         LruCacheWithExpiration cache = new LruCacheWithExpiration(3, 2000);
+
+        cache.put("key1", "value1");
+        cache.put("key2", "value2");
+        cache.put("key3", "value3");
+
+        // 更新key2的值，应将其移到最近使用的位置
+        cache.put("key2", "new_value2");
+
+        try {
+            Thread.sleep(1500);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        cache.put("key4", "value4");
+
+        // 验证更新后，key2未因LRU被淘汰，且旧值被替换
+        System.out.println("获取key2的值: " + cache.get("key2"));
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+          // 验证部分元素过期后，缓存的情况
+        System.out.println("获取key1的值: " + cache.get("key1"));
+        System.out.println("获取key3的值: " + cache.get("key3"));
+
+
+    }
+}
diff --git a/java/java_test/src/cache/LruCacheWithExpiration.java b/java/java_test/src/cache/LruCacheWithExpiration.java
@@ -0,0 +1,87 @@
+package cache;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/12/8 11:51
+ * @description
+ */
+public class LruCacheWithExpiration {
+    private int capacity;
+
+    private final Map<Object, LruNode> cache;
+
+    private final LinkedList<LruNode> linkedList;
+
+    private final long expireTime;
+
+    public LruCacheWithExpiration(int capacity, long expireTime) {
+        this.capacity = capacity;
+        this.cache = new HashMap<>();
+        this.linkedList = new LinkedList<>();
+        this.expireTime = expireTime;
+    }
+
+    //put
+    public void put(Object key, Object val){
+        LruNode node;
+        if(cache.containsKey(key)){
+            node = cache.get(key);
+            node.value = val;
+            node.timestamp = System.currentTimeMillis();
+            linkedList.remove(node);
+            linkedList.addFirst(node);
+        }else {
+            node = new LruNode(key, val);
+            if(cache.size() >= capacity){
+                removeExipredAndLastUsed();
+            }
+            cache.put(key, node);
+            linkedList.addFirst(node);
+        }
+    }
+
+    //删除过期的最近的
+    public void removeExipredAndLastUsed() {
+        while (!linkedList.isEmpty()){
+            LruNode node = linkedList.getLast();
+            if(isExpired(node)){
+                linkedList.removeLast();
+                cache.remove(node.key);
+            }else {
+                break;
+            }
+        }
+        if(!linkedList.isEmpty()){
+            LruNode nodeToRemove = linkedList.getLast();
+            linkedList.removeLast();
+            cache.remove(nodeToRemove.key);
+        }
+    }
+
+    //是否过期
+    public boolean isExpired(LruNode node) {
+        return System.currentTimeMillis() - node.timestamp > expireTime;
+    }
+
+    //get
+    public Object get(Object key){
+        if(cache.containsKey(key)){
+            LruNode node = cache.get(key);
+            node.timestamp = System.currentTimeMillis();
+            linkedList.remove(node);
+            linkedList.addFirst(node);
+            return node.value;
+        }
+        return null;
+    }
+
+    public static void main(String[] args) {
+
+    }
+}
diff --git a/java/java_test/src/cache/LruNode.java b/java/java_test/src/cache/LruNode.java
@@ -0,0 +1,18 @@
+package cache;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/12/8 11:50
+ * @description
+ */
+public class LruNode {
+    public Object key;
+    public Object value;
+    public long timestamp;
+    public LruNode(Object key, Object value) {
+        this.key = key;
+        this.value = value;
+        this.timestamp = System.currentTimeMillis();
+    }
+}
diff --git a/java/java_test/src/guc/Counter.java b/java/java_test/src/guc/Counter.java
@@ -0,0 +1,68 @@
+package guc;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/12/6 22:38
+ * @description 原子操作
+ */
+public class Counter {
+    private int i = 0;
+    private AtomicInteger atomicInteger = new AtomicInteger(0);
+    public static void main(String[] args) {
+        final Counter cas = new Counter();
+        List<Thread> ts = new ArrayList<>(600);
+        long start = System.currentTimeMillis();
+        for (int i = 0; i < 100; i++){
+            Thread t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    for (int i = 0; i < 1000; i ++){
+                        cas.count();
+                        cas.safeCount();
+                    }
+                }
+            });
+            ts.add(t);
+        }
+        for (Thread t :ts){
+            t.start();
+        }
+        //所有线程完成
+        for (Thread t: ts){
+            try{
+                t.join();
+            }catch (InterruptedException e){
+                e.printStackTrace();
+            }
+        }
+        System.out.println(String.format("计数器:%s", cas.i));
+        System.out.println(String.format("value:%s", cas.atomicInteger.get()));
+        System.out.println(String.format("耗时：%s", System.currentTimeMillis() - start));
+    }
+
+    /**
+     * 非线程安全计数器
+     * */
+    public void count(){
+        i++;
+    }
+
+    /**
+     * CAS线程安全计数器
+     * */
+    public void  safeCount(){
+        for (;;){
+            int i = atomicInteger.get();
+            boolean suc = atomicInteger.compareAndSet(i , ++i);
+            if (suc){
+                break;
+            }
+        }
+    }
+}
diff --git a/java/java_test/src/test/Solution.java b/java/java_test/src/test/Solution.java
@@ -0,0 +1,51 @@
+package test;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/12/5 16:45
+ * @description
+ */
+public class Solution {
+    public static String getPermutation(int n, int k) {
+        int fact[] = new int[n];
+        fact[0] = 1;
+        for (int i = 1; i < n; ++i){
+            System.out.println("i:" + i);
+            fact[i] = fact[i-1]*i;
+        }
+//        System.out.println(Arrays.toString(fact));
+        k = k - 1;
+        StringBuffer ans = new StringBuffer();
+        int[] valid = new int[n + 1];
+        Arrays.fill(valid, 1);
+        System.out.println(Arrays.toString(fact));
+        System.out.println(Arrays.toString(valid));
+
+        for (int i = 1; i <= n; ++i){
+            int order = k / fact[n - i] + 1;
+            System.out.println(order);
+            for (int j = 1; j <= n; ++ j){
+                order -= valid[j];
+                if (order == 0){
+                    ans.append(j);
+                    valid[j] = 0;
+                    break;
+                }
+            }
+            k %= fact[n - i];
+            System.out.println("k:" + k);
+        }
+        return ans.toString();
+    }
+
+    public static void main(String[] args) {
+        int n = 3;
+        int k = 3;
+        String res = getPermutation(n, k);
+        System.out.println(res);
+    }
+}
diff --git a/java/java_test/src/test/Test.java b/java/java_test/src/test/Test.java
@@ -0,0 +1,53 @@
+package test;
+
+import java.util.Arrays;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/12/5 14:26
+ * @description
+ *
+ * 连续子数组最大和
+ *
+ * 输入：[-1, 1, 2, 3, -4, 0, 5, -2]
+ *
+ * 输出： 7 （[1, 2, 3, -4, 0, 5] ）
+ */
+public class Test {
+    public static int maxSubArray(int[] nums){
+        if(nums == null || nums.length == 0)
+            return 0;
+        int curSum = nums[0];
+        int maxSum = nums[0];
+        int starIdx = 0;
+        int endIdx = 0;
+        int tempIdx = 0;
+        for (int i = 1; i < nums.length; i++){
+            if(curSum + nums[i] > nums[i]){
+                curSum += nums[i];
+            }else {
+                curSum = nums[i];
+                tempIdx = i;
+            }
+            if(curSum > maxSum){
+                maxSum = curSum;
+                starIdx = tempIdx;
+                endIdx = i;
+            }
+
+//            curSum = Math.max(curSum + nums[i], nums[i]);
+//            maxSum = Math.max(maxSum, curSum);
+        }
+        int[] res = new int[endIdx - starIdx + 1];
+        System.arraycopy(nums, starIdx, res, 0 , endIdx - starIdx + 1);
+        System.out.println(Arrays.toString(res));
+        return maxSum;
+    }
+
+    public  static void main(String[] args){
+        int[] nums = new int[]{-1, 1, 2, 3, -4, 0, 5, -2};
+        int res = maxSubArray(nums);
+        System.out.println(res);
+    }
+}
diff --git a/python/permut/__init__.py b/python/permut/__init__.py
diff --git a/python/permut/permute.py b/python/permut/permute.py
diff --git a/python/sort/readme.md b/python/sort/readme.md
