updat algorithm

Author: deleiguo

source/java/interview/delei-interview-algorithm/src/main/java/cn/delei/algorithm/lru/LRUCache.java

@@ -0,0 +1,67 @@
+package cn.delei.algorithm.lru;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+/**
+ * LRU实现：LinkedList+HashMap
+ *
+ * @param <K> 键
+ * @param <V> 键值
+ * @author deleiguo
+ */
+public class LRUCache<K, V> {
+    int capacity;
+    Map<K, V> map;
+    LinkedList<K> list;
+
+    public LRUCache(int capacity) {
+        this.capacity = capacity;
+        this.map = new HashMap<>();
+        this.list = new LinkedList<>();
+    }
+
+    /**
+     * 添加元素
+     * 1.元素存在，放到队尾
+     * 2.不存在，判断链表是否满。
+     * 如果满，则删除队首元素，放入队尾元素，删除更新哈希表
+     * 如果不满，放入队尾元素，更新哈希表
+     */
+    public void put(K key, V value) {
+        V v = map.get(key);
+        if (v != null) {
+            list.remove(key);
+            list.addLast(key);
+            map.put(key, value);
+            return;
+        }
+
+        //队列未满，添加到尾部
+        if (list.size() < capacity) {
+            list.addLast(key);
+            map.put(key, value);
+        } else {
+            //队列已满，移除队首
+            K firstKey = list.removeFirst();
+            map.remove(firstKey);
+            list.addLast(key);
+            map.put(key, value);
+        }
+    }
+
+    /**
+     * 访问元素
+     * 元素存在，放到队尾
+     */
+    public V get(K key) {
+        V v = map.get(key);
+        if (v != null) {
+            list.remove(key);
+            list.addLast(key);
+            return v;
+        }
+        return null;
+    }
+}

source/java/interview/delei-interview-algorithm/src/main/java/cn/delei/algorithm/lru/LRULinkedHashMap.java

@@ -0,0 +1,37 @@
+package cn.delei.algorithm.lru;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * LRU实现：LinkedHashMap
+ *
+ * @param <K> 键
+ * @param <V> 键值
+ * @author deleiguo
+ */
+public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {
+    private static final long serialVersionUID = -3788497546136920185L;
+
+    /**
+     * 容量
+     */
+    private final int capacity;
+
+    LRULinkedHashMap(int capacity) {
+        // 初始大小，0.75是装载因子，true是表示按照访问时间排序，最近访问的放在头部，最老访问的放在尾部
+        super(capacity, 0.75f, true);
+        // 指定最大容量
+        this.capacity = capacity;
+    }
+
+    /**
+     * 核心实现
+     */
+    @Override
+    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
+        // 如果map里面的元素个数大于了缓存最大容量，则删除链表的顶端元素，即最老的数据
+        return size() > capacity;
+    }
+
+}

source/java/interview/delei-interview-algorithm/src/main/java/cn/delei/algorithm/lru/LRULinkedHashMapWithLock.java

@@ -0,0 +1,81 @@
+package cn.delei.algorithm.lru;
+
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * 带有 Lock 操作
+ *
+ * @param <K> 键
+ * @param <V> 键值
+ * @author deleiguo
+ */
+public class LRULinkedHashMapWithLock<K, V> extends LRULinkedHashMap<K, V> {
+    private static final long serialVersionUID = -480172344142509767L;
+
+    private final Lock lock = new ReentrantLock();
+
+    LRULinkedHashMapWithLock(int capacity) {
+        super(capacity);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        lock.lock();
+        try {
+            return super.containsValue(value);
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    public V get(Object key) {
+        lock.lock();
+        try {
+            return super.get(key);
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    public V put(K key, V value) {
+        lock.lock();
+        try {
+            return super.put(key, value);
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    public int size() {
+        lock.lock();
+        try {
+            return super.size();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    public void clear() {
+        lock.lock();
+        try {
+            super.clear();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        lock.lock();
+        try {
+            return super.containsKey(key);
+        } finally {
+            lock.unlock();
+        }
+    }
+}

source/java/interview/delei-interview-algorithm/src/main/java/cn/delei/algorithm/lru/LRUTest.java

@@ -0,0 +1,19 @@
+package cn.delei.algorithm.lru;
+
+/**
+ * LRU 测试
+ */
+public class LRUTest {
+
+    public static void main(String[] args) {
+        linkedHashMapTest();
+    }
+
+    private static void linkedHashMapTest() {
+        LRULinkedHashMap<Integer, String> lru = new LRULinkedHashMap<>(5);
+        for (int i = 0; i < 10; i++) {
+            lru.put(i, i + "i");
+        }
+        System.out.println(lru.toString());
+    }
+}

source/java/interview/delei-interview-algorithm/src/main/java/cn/delei/algorithm/sort/BubbleSort.java

@@ -1,5 +1,7 @@
 package cn.delei.algorithm.sort;
 
+import cn.delei.algorithm.SwapNumber;
+
 import java.util.Arrays;
 
 /**
@@ -18,9 +20,7 @@ public int[] sort(int[] data) {
             flag = true;
             for (int j = 0; j < arr.length - i; j++) {
                 if (arr[j] > arr[j + 1]) {
-                    int tmp = arr[j];
-                    arr[j] = arr[j + 1];
-                    arr[j + 1] = tmp;
+                    SwapNumber.swapByTemp(arr, j, j + 1);
                     flag = false;
                 }
             }

source/java/interview/delei-interview-algorithm/src/main/java/cn/delei/algorithm/sort/InsertSort.java

@@ -10,23 +10,30 @@
 public class InsertSort implements IArraySort {
     @Override
     public int[] sort(int[] data) {
+        if (data.length < 2) {
+            return data;
+        }
         // 对 arr 进行拷贝，不改变参数内容
         int[] arr = Arrays.copyOf(data, data.length);
         // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
         int temp, j;
+        // i从1开始
         for (int i = 1; i < arr.length; i++) {
             // 记录要插入的数据
             temp = arr[i];
             // 从已经排序的序列最右边的开始比较，找到比其小的数
-            j = i;
-            while (j > 0 && temp < arr[j - 1]) {
-                arr[j] = arr[j - 1];
-                j--;
-            }
-            // 存在比其小的数，插入
-            if (j != i) {
-                arr[j] = temp;
+            j = i - 1;
+            // 查找插入的位置
+            for (; j >= 0; --j) {
+                if (arr[j] > temp) {
+                    // 数据移动
+                    arr[j + 1] = arr[j];
+                } else {
+                    break;
+                }
             }
+            // 插入数据
+            arr[j + 1] = temp;
         }
         return arr;
     }

source/java/interview/delei-interview-algorithm/src/main/java/cn/delei/algorithm/sort/SelectionSort.java

@@ -14,7 +14,7 @@ public class SelectionSort implements IArraySort {
     public int[] sort(int[] data) {
         int[] arr = Arrays.copyOf(data, data.length);
         // 总共要经过 N-1 轮比较
-        int min, temp;
+        int min;
         for (int i = 0; i < arr.length - 1; i++) {
             min = i;
             // 每轮需要比较的次数 N-i