Day33 Generic

1. 用双向链表实现LRU，要求可以指定缓存大小，并且可以存储任意类型的数据。

(要求用泛型，只需要实现添加方法即可)。

package week6.day33;

/**
* @author : 魏铭志
* @date :  2020/4/7 17:45
*/
public class  Node <T> {
   T value;
   Node<T> next;
   Node<T> pre;

   public Node(T value) {
       this.value = value;
   }

   public Node<T> add(T value) {
       Node<T> node = new Node<>(value);
       return add(node);
   }

   public Node<T> add(Node<T> node) {
       next = node;
       node.pre = this;
       return next;
   }


   @Override
   public boolean equals(Object t) {
       return t.equals(this.value);
   }

   @Override
   public String toString() {
       if (this.next == null) {
           return ""+value;
       }
       return value+"-->"+this.next.toString();
   }

}
package week6.day33;


/**
* @author : 魏铭志
* @date :  2020/4/7 17:45
*/
public class Test2 {
   public static void main(String[] args) {

       LRU<Integer> lru = new LRU<>(10);
       for (int i = 11; i > -1; i--) {
           lru.add(i);
       }
       System.out.println(lru);
       System.out.println("lru = " + lru);
       System.out.println(lru.size);
       lru.delete(3);
       System.out.println("lru = " + lru);
       lru.find(9);
       System.out.println("lru = " + lru);
       System.out.println(lru.size);
       lru.add(55).add(164);
       System.out.println("lru = " + lru+" "+lru.size);
   }
}

class LRU<T> {
   int size = 0;
   private Node<T> node;
   private int sizeMax ;
   private Node<T> lastNode;

   public LRU(int sizeMax) {
       this.sizeMax = sizeMax;
   }

   public LRU(T value) {
       node = new Node<>(value);
       lastNode = node;
       this.size++;
       sizeMax = 100;
   }

   private void lastNode() {
       Node<T> node = this.lastNode;
       while (node.next != null) {
           node = node.next;
       }
       lastNode = node;
   }

   Node<T> valueCheck(T value) {
       Node<T> x = this.node;
       do {
           if (value.equals(x.value)) {
               return x;
           }
           x = x.next;
       } while (x != null);
       return null;
   }

   LRU<T> add(T value) {
       if (this.node == null) {
           node = new Node<>(value);
           lastNode = node;
           size++;
           return this;
       }
       Node<T> valueCheck = valueCheck(value);
       if (valueCheck != null) {
           delete(valueCheck);
       } else {
           valueCheck = new Node<>(value);
       }
       if (size >= sizeMax) {
           lastNode();
           delete(lastNode);
       }
       valueCheck.add(this.node);
       this.node = valueCheck;
       this.node.pre = null;
       this.size++;
       return this;
   }

   private void delete(Node<T> node) {
       this.size--;
       if (node == lastNode) {
           lastNode = lastNode.pre;
       }
       if (node.pre == null) {
           node.next.pre = null;
           this.node = node.next;
           return;
       } else if (node.next == null) {
           node.pre.next = null;
           return;
       }
       node.pre.next = node.next;
       node.next.pre = node.pre;
   }

   LRU<T> delete(T value) {
       Node<T> valueCheck = valueCheck(value);
       if (valueCheck == null) {
           return this;
       }
       delete(valueCheck);
       return this;
   }

   LRU<T> find(T value) {
       Node<T> valueCheck = valueCheck(value);
       if (valueCheck != null) {
           delete(valueCheck);
           valueCheck.add(node);
           node = valueCheck;
           node.pre = null;
           size++;
       }
       return this;
   }

   @Override
   public String toString() {
       return "node=" + node;
   }
}

2. 合并两个有序的链表, 合并后的链表也是有序的。

举例：

  输入：1 --> 2 --> 5 --> null

2 --> 4 --> 7 --> null

  输出：1 --> 2 --> 2 --> 4 --> 5 --> 7 --> null

package week6.day33;

/**
* @author : 魏铭志
* @date :  2020/4/9 18:34
*/
public class Test3 {

   public static void main(String[] args) {
       Node node1 = new Node(1);
       node1.add(2).add(5);
       System.out.println("node1 = " + node1);
       Node node2 = new Node(2);
       node2.add(4).add(7);
       System.out.println("node2 = " + node2);
       System.out.println(node1.add(node2));


   }

   private static class Node {
       int value;
       Node next;

       public Node(int value) {
           this.value = value;
       }

       Node add(int value) {
           next = new Node(value);
           return next;
       }

       private void addAll(Node node) {
           this.next = node;
       }

       Node add(Node node) {
           Node x = this;
           while (node != null) {
               if (x.next == null) {
                   x.addAll(node);
                   break;
               }
               if (x.value <= node.value && x.next.value > node.value) {
                   if (x.value == node.value) {
                       node = node.next;
                       continue;
                   }
                   Node temp = node.next;
                   node.next = x.next;
                   x.next = node;
                   node = temp;
               } else {
                   x = x.next;
               }
           }
           return this;
       }

       @Override
       public String toString() {
           if (this.next == null) {
               return value+"-->"+"null";
           }
           return value+"-->"+this.next.toString();
       }
   }

}