diff --git "a/\344\275\234\344\270\232\344\270\200/LRU \347\274\223\345\255\230\346\267\230\346\261\260\347\256\227\346\263\225\347\232\204\351\223\276\350\241\250\345\256\236\347\216\260(optional)/LRULinkedHashMap.java" "b/\344\275\234\344\270\232\344\270\200/LRU \347\274\223\345\255\230\346\267\230\346\261\260\347\256\227\346\263\225\347\232\204\351\223\276\350\241\250\345\256\236\347\216\260(optional)/LRULinkedHashMap.java"
new file mode 100644
index 0000000000000000000000000000000000000000..1480ba8216d70bf07828fb3370e682790a82fe92
--- /dev/null
+++ "b/\344\275\234\344\270\232\344\270\200/LRU \347\274\223\345\255\230\346\267\230\346\261\260\347\256\227\346\263\225\347\232\204\351\223\276\350\241\250\345\256\236\347\216\260(optional)/LRULinkedHashMap.java"	
@@ -0,0 +1,81 @@
+import java.util.ArrayList;  
+import java.util.Collection;  
+import java.util.LinkedHashMap;  
+import java.util.concurrent.locks.Lock;  
+import java.util.concurrent.locks.ReentrantLock;  
+import java.util.Map; 
+
+public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {  
+    private final int maxCapacity;  
+
+    private static final float DEFAULT_LOAD_FACTOR = 0.75f;  
+
+    private final Lock lock = new ReentrantLock();  
+
+    public LRULinkedHashMap(int maxCapacity) {  
+        super(maxCapacity, DEFAULT_LOAD_FACTOR, true);  
+        this.maxCapacity = maxCapacity;  
+    }  
+
+    @Override 
+    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {  
+        return size() > maxCapacity;  
+    }  
+    @Override 
+    public boolean containsKey(Object key) {  
+        try {  
+            lock.lock();  
+            return super.containsKey(key);  
+        } finally {  
+            lock.unlock();  
+        }  
+    }  
+
+
+    @Override 
+    public V get(Object key) {  
+        try {  
+            lock.lock();  
+            return super.get(key);  
+        } finally {  
+            lock.unlock();  
+        }  
+    }  
+
+    @Override 
+    public V put(K key, V value) {  
+        try {  
+            lock.lock();  
+            return super.put(key, value);  
+        } finally {  
+            lock.unlock();  
+        }  
+    }  
+
+    public int size() {  
+        try {  
+            lock.lock();  
+            return super.size();  
+        } finally {  
+            lock.unlock();  
+        }  
+    }  
+
+    public void clear() {  
+        try {  
+            lock.lock();  
+            super.clear();  
+        } finally {  
+            lock.unlock();  
+        }  
+    }  
+
+    public Collection<Map.Entry<K, V>> getAll() {  
+        try {  
+            lock.lock();  
+            return new ArrayList<Map.Entry<K, V>>(super.entrySet());  
+        } finally {  
+            lock.unlock();  
+        }  
+    }  
+} 
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232\344\270\200/\344\270\244\344\270\252\346\234\211\345\272\217\347\232\204\351\223\276\350\241\250\345\220\210\345\271\266/BuildList.java" "b/\344\275\234\344\270\232\344\270\200/\344\270\244\344\270\252\346\234\211\345\272\217\347\232\204\351\223\276\350\241\250\345\220\210\345\271\266/BuildList.java"
new file mode 100644
index 0000000000000000000000000000000000000000..305971550dde31946c08b08127e27440cfd80dee
--- /dev/null
+++ "b/\344\275\234\344\270\232\344\270\200/\344\270\244\344\270\252\346\234\211\345\272\217\347\232\204\351\223\276\350\241\250\345\220\210\345\271\266/BuildList.java"
@@ -0,0 +1,100 @@
+     public class BuildList {
+	public static void main(String[] args) {
+		BuildList bl1 = new BuildList();
+		BuildList bl2 = new BuildList();
+		for (int i = 0; i < 10; i++) {
+			if (i % 2 == 0) {
+				bl1.addNode(i);
+			} else {
+				continue;
+			}
+
+		}
+		for (int i = 0; i < 10; i++) {
+			if (i % 2 != 0) {
+				bl2.addNode(i);
+			} else {
+				continue;
+			}
+		}
+		MergeSortedList msl = new MergeSortedList();
+		msl.merge(bl1.head, bl2.head);
+		msl.printList();
+	}
+
+	public Node head = null;
+
+	public void addNode(int k) {
+		Node newNode = new Node(k);
+		if (head == null) {
+			head = newNode;
+			return;
+		}
+		Node lastNode = head;
+		while (lastNode.next != null) {
+			lastNode = lastNode.next;
+		}
+		lastNode.next = newNode;
+	}
+
+	public void printList() {
+		Node printNode = head;
+		while (printNode != null) {
+			System.out.println(printNode.data);
+			printNode = printNode.next;
+		}
+	}
+}
+
+class Node {
+	public int data;
+	public Node next;
+
+	public Node(int data) {
+		this.data = data;
+	}
+
+}
+
+class MergeSortedList {
+	public Node merge;
+
+	public void merge(Node node_1, Node node_2) {
+		Node p1 = node_1;
+		Node p2 = node_2;
+		if (p1.data > p2.data) {
+			merge = p2;
+			p2 = p2.next;
+
+		} else {
+			merge = p1;
+			p1 = p1.next;
+		}
+		Node p = merge;
+		while (p1 != null && p2 != null) {
+			if (p1.data >= p2.data) {
+				p.next = p2;
+				p2 = p2.next;
+				p = p.next;
+			} else {
+				p.next = p1;
+				p1 = p1.next;
+				p = p.next;
+			}
+		}
+		if (p1 != null) {
+			p.next = p1;
+		}
+		if (p2 != null) {
+			p.next = p2;
+		}
+	}
+
+	public void printList() {
+		Node printNode = merge;
+		while (printNode != null) {
+			System.out.println(printNode.data);
+			printNode = printNode.next;
+		}
+	}
+}
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232\344\270\200/\345\210\240\351\231\244\345\217\214\345\220\221\351\223\276\350\241\250\345\200\222\346\225\260\347\254\254 n \344\270\252\347\273\223\347\202\271/MontageLinkedList.java" "b/\344\275\234\344\270\232\344\270\200/\345\210\240\351\231\244\345\217\214\345\220\221\351\223\276\350\241\250\345\200\222\346\225\260\347\254\254 n \344\270\252\347\273\223\347\202\271/MontageLinkedList.java"
new file mode 100644
index 0000000000000000000000000000000000000000..0d47d447c311ed9bcf8edf18edd3fc969d79dee5
--- /dev/null
+++ "b/\344\275\234\344\270\232\344\270\200/\345\210\240\351\231\244\345\217\214\345\220\221\351\223\276\350\241\250\345\200\222\346\225\260\347\254\254 n \344\270\252\347\273\223\347\202\271/MontageLinkedList.java"	
@@ -0,0 +1,56 @@
+public class MontageLinkedList {
+	
+	int value;
+	MontageLinkedList next;
+	
+	public MontageLinkedList(int val) {
+		value = val;
+	}
+	
+ 
+	public static void main(String[] args) {
+		MontageLinkedList mon1 = new MontageLinkedList(3);
+		MontageLinkedList mon2 = new MontageLinkedList(4);
+		MontageLinkedList mon3 = new MontageLinkedList(9);
+		MontageLinkedList mon4 = new MontageLinkedList(29);
+		MontageLinkedList mon5 = new MontageLinkedList(20);
+		
+		mon1.next = mon2;
+		mon2.next = mon3;
+		mon3.next = mon4;
+		mon4.next = mon5;
+		
+		MontageLinkedList l = getMontageLink(3, mon1);
+		while(l != null) {
+			System.out.print(l.value + " ");
+			l = l.next;
+		}
+ 
+	}
+	/**
+	 * @param n
+	 * @param li
+	 * @return
+	 * 思路：
+	 * 1、设置两个指针，第一个先走，走到n+1的位置；
+	 * 2、直到第二个指针开始走，第一个指针与第二个指针之间间隔n个数；
+	 */
+	public static MontageLinkedList getMontageLink(int n, MontageLinkedList li) {
+		MontageLinkedList list = new MontageLinkedList(0);
+		list.next = li;
+		MontageLinkedList first = list;
+		MontageLinkedList second = list;
+		
+		for(int i = 1; i < n + 1; i++) {
+			first = first.next;
+		}
+		
+		while(first != null) {
+			first = first.next;
+			second = second.next;
+		}
+		
+		second.next = second.next.next;
+		return list.next;
+	}
+}
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232\344\270\200/\345\215\225\351\223\276\350\241\250\345\217\215\350\275\254/JavaTest1.java" "b/\344\275\234\344\270\232\344\270\200/\345\215\225\351\223\276\350\241\250\345\217\215\350\275\254/JavaTest1.java"
new file mode 100644
index 0000000000000000000000000000000000000000..c391e8338c3b73875fecdea19c7495eda41d30c1
--- /dev/null
+++ "b/\344\275\234\344\270\232\344\270\200/\345\215\225\351\223\276\350\241\250\345\217\215\350\275\254/JavaTest1.java"
@@ -0,0 +1,78 @@
+  public class JavaTest1 {
+	public static void main(String[] args) {
+		Node head = new Node(0);
+		Node node1 = new Node(1);
+		Node node2 = new Node(2);
+		Node node3 = new Node(3);
+ 
+		head.setNext(node1);
+		node1.setNext(node2);
+		node2.setNext(node3);
+ 
+		// 打印反转前的链表
+		Node h = head;
+		while (null != h) {
+			System.out.print(h.getData() + " ");
+			h = h.getNext();
+		}
+		// 调用反转方法
+		// head = reverse1(head);
+		head = reverse2(head);
+ 
+		System.out.println("\n**************************");
+		// 打印反转后的结果
+		while (null != head) {
+			System.out.print(head.getData() + " ");
+			head = head.getNext();
+		}
+	}
+ 
+	/**
+	 * 遍历，将当前节点的下一个节点缓存后更改当前节点指针
+	 */
+	public static Node reverse2(Node head) {
+		if (head == null)
+			return head;
+		Node pre = head;// 上一结点
+		Node cur = head.getNext();// 当前结点
+		Node tmp;// 临时结点，用于保存当前结点的指针域（即下一结点）
+		while (cur != null) {// 当前结点为null，说明位于尾结点
+			tmp = cur.getNext();
+			cur.setNext(pre);// 反转指针域的指向
+ 
+			// 指针往下移动
+			pre = cur;
+			cur = tmp;
+		}
+		// 最后将原链表的头节点的指针域置为null，还回新链表的头结点，即原链表的尾结点
+		head.setNext(null);
+		
+		return pre;
+	}
+}
+ 
+class Node {
+	private int Data;// 数据域
+	private Node Next;// 指针域
+ 
+	public Node(int Data) {
+		// super();
+		this.Data = Data;
+	}
+ 
+	public int getData() {
+		return Data;
+	}
+ 
+	public void setData(int Data) {
+		this.Data = Data;
+	}
+ 
+	public Node getNext() {
+		return Next;
+	}
+ 
+	public void setNext(Node Next) {
+		this.Next = Next;
+	}
+}
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232\344\270\200/\345\217\214\345\220\221\351\223\276\350\241\250/DoublyLinkedList.java" "b/\344\275\234\344\270\232\344\270\200/\345\217\214\345\220\221\351\223\276\350\241\250/DoublyLinkedList.java"
new file mode 100644
index 0000000000000000000000000000000000000000..5d1aff548d7dd07033fa2122e74bf6719ec0079a
--- /dev/null
+++ "b/\344\275\234\344\270\232\344\270\200/\345\217\214\345\220\221\351\223\276\350\241\250/DoublyLinkedList.java"
@@ -0,0 +1,158 @@
+package com.Node.LinkList;
+
+public class DoublyLinkedList<T> {
+	public static void main(String[] args){
+        DoublyLinkedList<Integer> list= new DoublyLinkedList<>();
+        for(int i=6;i>0;i--) list.PushFront(i);
+        for(int i=4;i<11;i++) list.PushBack(i);
+        System.out.println(list.TopFront()+" "+list.TopBack());//test TopFront and TopBack
+        list.AddAfter(list.getNode(),14);
+        System.out.println(list.Find(22)+" "+list.Find(9));
+        list.Erase(11);
+    }
+    //鍒涘缓鑺傜偣
+    private class Node{
+        private T value;
+        private Node next;
+        private Node prev;
+        public Node(T value){
+            this.value=value;
+            this.next=null;
+            this.prev=null;
+        }
+    }
+
+    private Node head;
+    private Node tail;
+    public DoublyLinkedList(){
+        this.head=null;
+        this.tail=null;
+    }
+    //empty list?
+    public boolean Empty(){
+        return this.head==null;
+    }
+    //add to front
+    //涓ょ鎯呭喌:閾捐〃涓虹┖鍜屾甯�
+    public void PushFront(T key){
+        Node node=new Node(key);//node.prev=null;
+        node.next=this.head;
+        this.head=node;
+        if(this.tail==null) this.tail=this.head;//鍘熸湰鏃犲厓绱犵殑璇�,闇�瑕佸皢灏捐妭鐐硅缃负鍒氭彃鍏ョ殑鏂拌妭鐐�
+        else this.head.next.prev=node;//鍘熸湰鏈夊厓绱犵殑璇濊缃師head鐨刾rev鑺傜偣
+    }
+    //return front item
+    public T TopFront(){
+        if(Empty()) throw new IndexOutOfBoundsException("linked list is empty");
+        return head.value;
+    }
+    //remove front item
+    //涓ょ鎯呭喌锛氬彧鏈変竴涓厓绱犲拰姝ｅ父
+    public void PopFront(){
+        if(Empty()) return;
+        if(this.head!=this.tail) this.head.next.prev=null;//涓や釜鍏冪礌鍙婁互涓婅璁剧疆prev鑺傜偣
+        this.head=this.head.next;
+        if(this.head==null) this.tail=null;//鍙湁涓�涓厓绱�,pop鍚庡彉涓虹┖閾捐〃
+    }
+    //add to back
+    public void PushBack(T key){
+        Node node=new Node(key);
+        if(this.tail==null){
+            this.head=this.tail=node;
+        }
+        else{
+            this.tail.next=node;
+            node.prev=this.tail;
+            this.tail=node;
+        }
+    }
+    //return back item
+    public T TopBack(){
+        if(Empty()) throw new IndexOutOfBoundsException("linked list is empty");
+        return tail.value;
+    }
+    //remove back item
+    //鎷ユ湁prev鑺傜偣鍚庢棤椤讳粠澶撮亶鍘�
+    public void PopBack(){
+        if(Empty()) return;
+        if(this.head==this.tail) this.head=this.tail=null;
+        else{
+            this.tail=this.tail.prev;
+            this.tail.next=null;
+        }
+    }
+    //is key in list?
+    public boolean Find(T key){
+        Node node=this.head;
+        while(node!=null){
+            if(node.value==key) return true;
+            node=node.next;
+        }
+        return false;
+    }
+    //remove key from list
+    public void Erase(T key){
+        Node node=this.head;
+        while(node!=null){
+            if(node.value==key){
+                if(this.head==this.tail){
+                this.head=this.tail=null;//鍙湁涓�涓厓绱�
+                break;
+                    }
+                else if(node==this.head) {
+                    this.head=this.head.next;//鍒犻櫎鐨勬槸澶村厓绱�
+                    this.head.prev=null;
+                }
+                else{
+                    node.prev.next=node.next;
+                    if(node==this.tail) this.tail=node.prev;//濡傛灉鍒犻櫎鐨勬槸灏捐妭鐐�,瑕佹敼鍙樺熬鑺傜偣
+                    else node.next.prev=node.prev; //闈炲熬鑺傜偣瑕佹敼鍙樿鍒犺妭鐐圭殑涓嬩竴涓妭鐐圭殑prev
+                }
+            }
+            node=node.next;
+        }
+    }
+    //adds keys before node
+    //鎷ユ湁prev鑺傜偣鍚庝笉鐢ㄩ亶鍘�
+    public void AddBefore(Node node, T key){
+        Node New=new Node(key);
+        if(node==this.head){
+            New.next=this.head;
+            this.head.prev=New;
+            this.head=New;
+        }
+        else{
+            node.prev.next=New;//鏀瑰彉琚彃鍏ヨ妭鐐瑰墠涓�涓妭鐐圭殑next鑺傜偣
+            New.prev=node.prev;//璁剧疆鎻掑叆鑺傜偣鐨刾rev鑺傜偣
+            New.next=node;
+            node.prev=New;
+        }
+    }
+    //adds key after node
+    public void AddAfter(Node node, T key){
+        Node New=new Node(key);
+        New.next=node.next;
+        New.prev=node;
+        node.next=New;
+        if(node==this.tail) this.tail=New;//濡傛灉鎻掑湪灏捐妭鐐瑰悗瑕佸彉鏇村熬鑺傜偣
+        else node.next.prev=New;//鎻掑叆鐨勪笉鍦ㄥ熬鑺傜偣鍚�,灏遍渶瑕佽鏀瑰彉鎻掑叆浣嶇疆鍚庝竴涓妭鐐圭殑prev鑺傜偣
+    }
+    //print the value of the whole linked list
+    public void Print(){
+        Node node=this.head;
+        while(node!=null) {
+            System.out.print(node.value+" ");
+            node=node.next;
+        }
+        System.out.println();
+    }
+
+    public Node getHead(){
+        return head;
+    }
+
+    public Node getNode(){
+        return head.next.next.next;
+    }
+
+}
diff --git "a/\344\275\234\344\270\232\344\270\200/\345\256\236\347\216\260\345\215\225\351\223\276\350\241\250/Node.java" "b/\344\275\234\344\270\232\344\270\200/\345\256\236\347\216\260\345\215\225\351\223\276\350\241\250/Node.java"
new file mode 100644
index 0000000000000000000000000000000000000000..66fc15a7c77a15ef2b19665be52afd91868a15ad
--- /dev/null
+++ "b/\344\275\234\344\270\232\344\270\200/\345\256\236\347\216\260\345\215\225\351\223\276\350\241\250/Node.java"
@@ -0,0 +1,177 @@
+  public class Node {
+	public static void main(String[] args) {
+		Link link = new Link();
+		// 添加数据
+		link.add(12);
+		link.add(34);
+		link.add(56);
+		link.add(78);
+		link.add(90);
+		// 遍历列表
+		for (int i = 0; i < link.getSize(); i++) {
+			// 取出元素
+			int e = link.get(i);
+			// 输出元素
+			System.out.println("第" + i + "个元素是：" + e);
+
+		}
+	}
+
+	int data;
+	Node next;
+
+	public Node() {
+	}
+
+	public Node(int data) {
+		this.data = data;
+	}
+}
+
+interface myList {
+	// 存储
+	public void add(int e);
+
+	// 插入
+	public void insert(int e, int index);
+
+	// 删除
+	public void delete(int index);
+	// 获取元素
+
+	public int get(int index);
+
+	// 修改
+	public void modify(int e, int index);
+
+	// 获取元素个数
+	public int getSize();
+}
+
+class Link implements myList {
+	Node head;
+	// 头结点
+	Node temp = head;
+	// 元素个数
+	int size;
+
+	public Link() {
+		head = new Node();
+		temp = head;
+		size = 0;
+	}
+
+	@Override
+	public void add(int e) {
+
+		// 创建一个新的结点
+		Node node = new Node(e);
+		// 设置下一个节点为新结点
+		temp.next = node;
+		// 设置新结点
+		temp = node;
+		// 元素个数加一
+		size++;
+
+	}
+
+	@Override
+	public void insert(int e, int index) {
+		checkindex(index);
+		Node node = head.next;
+		// 找到下标index
+		for (int i = 0; i < index; i++) {
+			node = node.next;
+		}
+		// 找到下标index-1
+		Node node1 = head.next;
+		for (int i = 0; i < index - 1; i++) {
+			node1 = node1.next;
+		}
+		// 创建一个新节点，为要插入的节点
+		Node node2 = new Node(e);
+		if (index == 0) {// 如果插入的位置是第一个节点
+			head.next = null;
+			head.next = node2;
+		} else {
+			node1.next = null;
+			node1.next = node2;
+		}
+		node2.next = node;
+		size++;
+
+	}
+
+	@Override
+	public void delete(int index) {
+		checkindex(index);
+		Node node = head.next;
+		// 找到下标index
+		for (int i = 0; i < index; i++) {
+			node = node.next;
+		}
+		// 找到下标index-1
+		Node node1 = head.next;
+		for (int i = 0; i < index - 1; i++) {
+			node1 = node1.next;
+		}
+		if (index != 0) {// 假设index不等于0；不是第一个节点
+			if (index == size - 1) {// 假设是最后一个
+				node1.next = null;
+			} else {// 假设不是最后一个
+				node1.next = null;
+				node1.next = node.next;
+			}
+			// 设置node的指针为空，node的值为空
+			node.next = null;
+			node.data = 0;
+		} else {// 假设index等于0
+			head.next = null;
+			head.next = node.next;
+			node.next = null;
+			node.data = 0;
+		}
+		size--;
+
+	}
+
+	@Override
+	public int get(int index) {
+		// 找到下表index
+		Node node = head.next;
+		// 从头节点开始，依次向后查找
+		for (int i = 0; i < index; i++) {
+			node = node.next;
+		}
+
+		return node.data;
+
+	}
+
+	@Override
+	public void modify(int e, int index) {
+		// 找到下表index
+		Node node = head.next;
+		// 从头节点开始，依次向后查找
+		for (int i = 0; i < index; i++) {
+			node = node.next;
+		}
+		Node node1 = new Node(e);
+		node.data = e;
+
+	}
+
+	@Override
+	public int getSize() {
+		// TODO Auto-generated method stub
+		return size;
+	}
+
+	// 检查index值是否合格
+	public void checkindex(int index) {
+		if (index < 0 || index > size) {
+			throw new IndexOutOfBoundsException("参数不符合要求");
+		}
+	}
+
+}
diff --git "a/\344\275\234\344\270\232\344\270\200/\345\260\276\346\214\207\351\222\210\347\232\204\345\215\225\351\223\276\350\241\250/Node.java" "b/\344\275\234\344\270\232\344\270\200/\345\260\276\346\214\207\351\222\210\347\232\204\345\215\225\351\223\276\350\241\250/Node.java"
new file mode 100644
index 0000000000000000000000000000000000000000..d90252fcc8328c3bc8c7e7610a71c5dca9ef412e
--- /dev/null
+++ "b/\344\275\234\344\270\232\344\270\200/\345\260\276\346\214\207\351\222\210\347\232\204\345\215\225\351\223\276\350\241\250/Node.java"
@@ -0,0 +1,177 @@
+public class Node {
+	public static void main(String[] args) {
+		Link link = new Link();
+		// 添加数据
+		link.add(12);
+		link.add(34);
+		link.add(56);
+		link.add(78);
+		link.add(90);
+		// 遍历列表
+		for (int i = 0; i < link.getSize(); i++) {
+			// 取出元素
+			int e = link.get(i);
+			// 输出元素
+			System.out.println("第" + i + "个元素是：" + e);
+
+		}
+	}
+
+	int data;
+	Node next;
+
+	public Node() {
+	}
+
+	public Node(int data) {
+		this.data = data;
+	}
+}
+
+interface myList {
+	// 存储
+	public void add(int e);
+
+	// 插入
+	public void insert(int e, int index);
+
+	// 删除
+	public void delete(int index);
+	// 获取元素
+
+	public int get(int index);
+
+	// 修改
+	public void modify(int e, int index);
+
+	// 获取元素个数
+	public int getSize();
+}
+
+class Link implements myList {
+	
+	// 头结点，尾节点
+	Node head,tail;
+	// 元素个数
+	int size;
+
+	public Link() {
+		head = new Node();
+		tail = head;
+		size = 0;
+	}
+
+	@Override
+	public void add(int e) {
+
+		// 创建一个新的结点
+		Node node = new Node(e);
+		// 设置尾结点的下一个节点为新结点
+		tail.next = node;
+		// 设置尾结点为新结点
+		tail = node;
+		// 元素个数加一
+		size++;
+
+	}
+
+	@Override
+	public void insert(int e, int index) {
+		checkindex(index);
+		Node node = head.next;
+		// 找到下标index
+		for (int i = 0; i < index; i++) {
+			node = node.next;
+		}
+		// 找到下标index-1
+		Node node1 = head.next;
+		for (int i = 0; i < index - 1; i++) {
+			node1 = node1.next;
+		}
+		// 创建一个新节点，为要插入的节点
+		Node node2 = new Node(e);
+		if (index == 0) {// 如果插入的位置是第一个节点
+			head.next = null;
+			head.next = node2;
+		} else {
+			node1.next = null;
+			node1.next = node2;
+		}
+		node2.next = node;
+		size++;
+
+	}
+
+	@Override
+	public void delete(int index) {
+		checkindex(index);
+		Node node = head.next;
+		// 找到下标index
+		for (int i = 0; i < index; i++) {
+			node = node.next;
+		}
+		// 找到下标index-1
+		Node node1 = head.next;
+		for (int i = 0; i < index - 1; i++) {
+			node1 = node1.next;
+		}
+		if (index != 0) {// 假设index不等于0；不是第一个节点
+			if (index == size - 1) {// 假设是最后一个
+				node1.next = null;
+			} else {// 假设不是最后一个
+				node1.next = null;
+				node1.next = node.next;
+			}
+			// 设置node的指针为空，node的值为空
+			node.next = null;
+			node.data = 0;
+		} else {// 假设index等于0
+			head.next = null;
+			head.next = node.next;
+			node.next = null;
+			node.data = 0;
+		}
+		size--;
+
+	}
+
+	@Override
+	public int get(int index) {
+		// 找到下表index
+		Node node = head.next;
+		// 从头节点开始，依次向后查找
+		for (int i = 0; i < index; i++) {
+			node = node.next;
+		}
+
+		return node.data;
+
+	}
+
+	@Override
+	public void modify(int e, int index) {
+		// 找到下表index
+		Node node = head.next;
+		// 从头节点开始，依次向后查找
+		for (int i = 0; i < index; i++) {
+			node = node.next;
+		}
+		Node node1 = new Node(e);
+		node.data = e;
+
+	}
+
+	@Override
+	public int getSize() {
+		// TODO Auto-generated method stub
+		return size;
+	}
+
+	// 检查index值是否合格
+	public void checkindex(int index) {
+		if (index < 0 || index > size) {
+			throw new IndexOutOfBoundsException("参数不符合要求");
+		}
+	}
+
+}
diff --git "a/\344\275\234\344\270\232\344\270\200/\346\261\202\351\223\276\350\241\250\347\232\204\344\270\255\351\227\264\347\273\223\347\202\271/ListNode2.java" "b/\344\275\234\344\270\232\344\270\200/\346\261\202\351\223\276\350\241\250\347\232\204\344\270\255\351\227\264\347\273\223\347\202\271/ListNode2.java"
new file mode 100644
index 0000000000000000000000000000000000000000..09952126b1509737fe372ba3449e2ca435cca8f5
--- /dev/null
+++ "b/\344\275\234\344\270\232\344\270\200/\346\261\202\351\223\276\350\241\250\347\232\204\344\270\255\351\227\264\347\273\223\347\202\271/ListNode2.java"
@@ -0,0 +1,32 @@
+  public class ListNode2 {
+    int val;
+    ListNode2 next;
+
+    ListNode2(int x) {
+        val = x;
+    }
+
+
+/**
+ * 寻找链表的中间节点
+ * 
+ * @param node
+ * @return
+ */
+  public static ListNode2 middleNode(ListNode2 head) {
+    if (head == null || head.next == null) {
+        return head;
+    }
+
+    ListNode2 slow = head;
+    ListNode2 fast = head.next;
+
+    while (fast != null && fast.next != null) {
+        slow = slow.next;
+        fast = fast.next.next;
+    }
+
+    
+    return fast == null ? slow : slow.next;
+}
+}
\ No newline at end of file