diff --git "a/\344\275\234\344\270\2321/LinkedList1.java" "b/\344\275\234\344\270\2321/LinkedList1.java"
new file mode 100644
index 0000000000000000000000000000000000000000..4a23a181eff3ea3e2756f54c4c5d2f512a2cc606
--- /dev/null
+++ "b/\344\275\234\344\270\2321/LinkedList1.java"
@@ -0,0 +1,106 @@
+public class LinkedList <E> {
+    private Node head;
+    private int size;
+
+
+    public LinkedList() {
+      head = null;
+    }
+
+    public void addToFront(E item) {
+        Node node = new Node(item);
+
+        if (this.head == null) {
+            this.head = node;
+        } else{
+            Node temp = head;
+            this.head = node;
+            this.head.next = temp;
+        }
+        size++;
+    }
+
+
+    public int size(){
+        return this.size;
+    }
+
+    public boolean findItems(E item){
+        Node temp=this.head;
+        if(temp==null){
+            System.out.println("empty");
+            return false;
+        }
+        while(temp.next!=null){
+            if(temp.item.equals(item))
+            {
+                return true;
+            }
+            temp=temp.next;
+        }
+        return false;
+    }
+
+    public void deleteItems(E item){
+        Node temp=this.head;
+        Node pretemp=new Node(item);
+        pretemp=temp;
+        if(temp==null){
+            System.out.println("empty");
+            return;
+        }
+        while(temp.next!=null){
+         //   System.out.println("temp"+temp.item);
+        //    System.out.println("ll"+this.head.item);   
+            if(temp.item.equals(item)){
+                if(this.head.item.equals(item)){
+                    pretemp=this.head.next;
+                    this.head.next=pretemp.next;
+                    this.head=pretemp;
+                    
+ //                   System.out.println("testss"+this.head.item);
+                    break;
+                }
+            System.out.println("delete"); 
+            pretemp.next=temp.next;
+            break;
+            }else
+            {
+                System.out.println("no delete");
+                pretemp=temp;
+                temp=temp.next;
+                      
+            }  
+            
+        }
+        if(temp.next==null){
+            temp.item=null;
+            temp.next=null;
+        }
+        this.size--;
+    }
+
+    public void addToRear(E item) {
+        Node newNode = new Node(item);
+        if (this.head == null) {
+            this.head = newNode;
+        } else {
+            
+            Node temp = this.head;
+            while(temp.next != null){
+              temp = temp.next;
+            }
+            temp.next = newNode;
+        }
+    }
+
+    public void print() {
+        Node temp = this.head;
+        while(temp.next != null){
+            System.out.print(temp.item + " -> ");
+            temp = temp.next;
+        }
+        System.out.println(temp.item);
+    }
+}
+
diff --git "a/\344\275\234\344\270\2321/LinkedList2.java" "b/\344\275\234\344\270\2321/LinkedList2.java"
new file mode 100644
index 0000000000000000000000000000000000000000..d89cf5842f165f5d7926c03541e8a65e20020d21
--- /dev/null
+++ "b/\344\275\234\344\270\2321/LinkedList2.java"
@@ -0,0 +1,206 @@
+package 作业基础2;
+
+public class He<T> {
+
+    //定义一个内部类Node
+    private class Node{
+        //保存节点数据
+        private T data;
+        //指向下一个节点引用
+        private Node next;
+        //无参构造器
+        public Node(){}
+
+        //初始化全部属性的构造器
+        public Node(T data,Node next){
+            this.data = data;
+            this.next = next;
+        }
+
+    }
+
+    //保存该链接的节点
+    private Node header;
+    //保存该链表的节点
+    private Node tail;
+    //保存该链表中已包含的节点数
+    private int size;
+    //创建空链表
+    public He(){
+        //空链表，header和tail 都是null
+        header = null;
+        tail = null;
+    }
+    //以指定数据元素来创建链表，该链表只有一个元素
+    public He(T element){
+        header = new Node(element,null);
+        //只有一个节点，header，tail都指向该节点
+        tail = header;//尾指针指向最后一个节点
+        size++;
+    }
+
+    //返回链表的长度
+    public int length(){
+        return size;
+    }
+
+    //获取链式线性表中索引为index处的元素
+    public T get(int index){
+        return getNodeByIndex(index).data;
+    }
+
+    //根据索引index获取指定位置的节点
+    private Node getNodeByIndex(int index){
+        if(index<0 || index >size - 1){
+            throw new IndexOutOfBoundsException("");
+        }
+        //从header节点开始
+        Node current = header;
+        for(int i = 0;i<size && current != null;i++,current=current.next){
+            if(i == index){
+                return current;
+            }
+        }
+        return null;
+    }
+    //查找链式线性表中指定元素的索引
+    public int locate(T element){
+        //从头节点开始搜索
+        Node current = header;
+        for(int i = 0;i<size && current !=null;i++,current= current.next){
+            if(current.data.equals(element)){
+                return i;
+            }
+        }
+        return -1;
+    }
+    //向线性链式表的指定位置插入一个元素
+    public void insert(T element,int index){
+        if(index<0 || index > size){
+            throw new IndexOutOfBoundsException("");
+        }
+        //如果还是空链表
+        if(header == null){
+            add(element);
+        }
+        else{
+            //当Index为0是，即在连表头处插入
+            if(index == 0){
+                addAtHeader(element);
+            }
+            else{
+                //获取插入点的前一个节点
+                Node prev= getNodeByIndex(index-1);
+                //让prev的next节点指向新节点，让新节点next引用指向原来prev的下一个节点
+                prev.next = new Node(element,prev.next);
+                size++;
+            }
+        }
+    }
+
+    //采用尾插法为立案表添加新节点
+    public void add(T element){
+        //如果该链表还是空链表
+        if(header == null){
+            header = new Node(element,null);
+            //只有一个节点header，tail都指向该节点
+            tail = header;
+        }
+        else{
+            //创建新节点
+            Node newNode = new Node(element,null);
+            //rang尾节点的next指向新增的节点
+            tail.next = newNode;
+            //以新节点做为新的尾节点
+            tail = newNode;
+        }
+        size++;
+    }
+    //采用头插法为链表添加新节点
+    public void addAtHeader(T element){
+        //创建新节点，让新节点next指向原来的 header
+        //并以新节点作为新的header
+        header = new Node(element,header);
+        //如果插入之前是空链表
+        if(tail == null){
+            tail = header;
+        }
+        size++;
+    }
+
+    //删除链式线性表中指定索引处的元素
+    public T delete(int index){
+        if(index< 0 || index >size -1){
+            throw new IndexOutOfBoundsException("");
+        }
+        Node del = null;
+        //如果删除的是header节点
+        if( index == 0){
+            del = header;
+            header = header.next;
+        }
+        else{
+            //获取删除点的前一个节点
+            Node prev = getNodeByIndex(index-1);
+            //获取僬侥被删除的节点
+            del = prev.next;
+            //让被删除节点的next指向被删除节点的下一个节点
+            prev.next = del.next;
+            //将被删除节点的next引用赋为null
+            del.next = null;
+
+        }
+        size--;
+        return del.data;
+    }
+    //删除线性表中最后一个元素
+    public T remove(){
+        return delete(size - 1);
+    }
+
+    //判断线性表是否为空
+    public boolean empty(){
+        return size == 0;
+    }
+
+    //清空线性表
+    public void clear(){
+        //将header tail 赋为null
+        header = null;
+        tail = null;
+        size = 0;
+    }
+
+    public String toString(){
+        //链表为空链表时
+        if(empty()){
+            return "[]";
+        }else{
+            StringBuilder sb = new StringBuilder("[");
+            for(Node current = header;current != null; current = current.next){
+                sb.append(current.data.toString()+", ");
+            }
+            int len = sb.length();
+            return sb.delete(len-2, len).append("]").toString();
+        }
+    }
+
+
+    public static void main(String[] args) {
+        He<String> list = new He<String>();
+        list.insert("aaa", 0);
+        //list.insert("cc", 3);  报错原因是索引越界了
+        list.add("bbb");
+        list.add("ccc");
+        list.add("ddd");
+        list.add("eee");
+
+
+        list.insert("插入", 2);
+
+       // list.delete(2);
+
+        System.out.println(list.toString());
+    }
+
+}
\ No newline at end of file
diff --git "a/\344\275\234\344\270\2321/LinkedList3.java" "b/\344\275\234\344\270\2321/LinkedList3.java"
new file mode 100644
index 0000000000000000000000000000000000000000..a4305203d25d136ffff60a2d819c26865440ae2e
--- /dev/null
+++ "b/\344\275\234\344\270\2321/LinkedList3.java"
@@ -0,0 +1,206 @@
+package 作业基础3;
+
+public class He<T> {
+
+    //定义一个内部类Node
+    private class Node{
+        //保存节点数据
+        private T data;
+        //指向下一个节点引用
+        private Node next;
+        //无参构造器
+        public Node(){}
+
+        //初始化全部属性的构造器
+        public Node(T data,Node next){
+            this.data = data;
+            this.next = next;
+        }
+
+    }
+
+    //保存该链接的节点
+    private Node header;
+    //保存该链表的节点
+    private Node tail;
+    //保存该链表中已包含的节点数
+    private int size;
+    //创建空链表
+    public He(){
+        //空链表，header和tail 都是null
+        header = null;
+        tail = null;
+    }
+    //以指定数据元素来创建链表，该链表只有一个元素
+    public He(T element){
+        header = new Node(element,null);
+        //只有一个节点，header，tail都指向该节点
+        tail = header;//尾指针指向最后一个节点
+        size++;
+    }
+
+    //返回链表的长度
+    public int length(){
+        return size;
+    }
+
+    //获取链式线性表中索引为index处的元素
+    public T get(int index){
+        return getNodeByIndex(index).data;
+    }
+
+    //根据索引index获取指定位置的节点
+    private Node getNodeByIndex(int index){
+        if(index<0 || index >size - 1){
+            throw new IndexOutOfBoundsException("");
+        }
+        //从header节点开始
+        Node current = header;
+        for(int i = 0;i<size && current != null;i++,current=current.next){
+            if(i == index){
+                return current;
+            }
+        }
+        return null;
+    }
+    //查找链式线性表中指定元素的索引
+    public int locate(T element){
+        //从头节点开始搜索
+        Node current = header;
+        for(int i = 0;i<size && current !=null;i++,current= current.next){
+            if(current.data.equals(element)){
+                return i;
+            }
+        }
+        return -1;
+    }
+    //向线性链式表的指定位置插入一个元素
+    public void insert(T element,int index){
+        if(index<0 || index > size){
+            throw new IndexOutOfBoundsException("");
+        }
+        //如果还是空链表
+        if(header == null){
+            add(element);
+        }
+        else{
+            //当Index为0是，即在连表头处插入
+            if(index == 0){
+                addAtHeader(element);
+            }
+            else{
+                //获取插入点的前一个节点
+                Node prev= getNodeByIndex(index-1);
+                //让prev的next节点指向新节点，让新节点next引用指向原来prev的下一个节点
+                prev.next = new Node(element,prev.next);
+                size++;
+            }
+        }
+    }
+
+    //采用尾插法为立案表添加新节点
+    public void add(T element){
+        //如果该链表还是空链表
+        if(header == null){
+            header = new Node(element,null);
+            //只有一个节点header，tail都指向该节点
+            tail = header;
+        }
+        else{
+            //创建新节点
+            Node newNode = new Node(element,null);
+            //rang尾节点的next指向新增的节点
+            tail.next = newNode;
+            //以新节点做为新的尾节点
+            tail = newNode;
+        }
+        size++;
+    }
+    //采用头插法为链表添加新节点
+    public void addAtHeader(T element){
+        //创建新节点，让新节点next指向原来的 header
+        //并以新节点作为新的header
+        header = new Node(element,header);
+        //如果插入之前是空链表
+        if(tail == null){
+            tail = header;
+        }
+        size++;
+    }
+
+    //删除链式线性表中指定索引处的元素
+    public T delete(int index){
+        if(index< 0 || index >size -1){
+            throw new IndexOutOfBoundsException("");
+        }
+        Node del = null;
+        //如果删除的是header节点
+        if( index == 0){
+            del = header;
+            header = header.next;
+        }
+        else{
+            //获取删除点的前一个节点
+            Node prev = getNodeByIndex(index-1);
+            //获取僬侥被删除的节点
+            del = prev.next;
+            //让被删除节点的next指向被删除节点的下一个节点
+            prev.next = del.next;
+            //将被删除节点的next引用赋为null
+            del.next = null;
+
+        }
+        size--;
+        return del.data;
+    }
+    //删除线性表中最后一个元素
+    public T remove(){
+        return delete(size - 1);
+    }
+
+    //判断线性表是否为空
+    public boolean empty(){
+        return size == 0;
+    }
+
+    //清空线性表
+    public void clear(){
+        //将header tail 赋为null
+        header = null;
+        tail = null;
+        size = 0;
+    }
+
+    public String toString(){
+        //链表为空链表时
+        if(empty()){
+            return "[]";
+        }else{
+            StringBuilder sb = new StringBuilder("[");
+            for(Node current = header;current != null; current = current.next){
+                sb.append(current.data.toString()+", ");
+            }
+            int len = sb.length();
+            return sb.delete(len-2, len).append("]").toString();
+        }
+    }
+
+
+    public static void main(String[] args) {
+        He<String> list = new He<String>();
+        list.insert("aaa", 0);
+        //list.insert("cc", 3);  报错原因是索引越界了
+        list.add("bbb");
+        list.add("ccc");
+        list.add("ddd");
+        list.add("eee");
+
+
+        list.insert("插入", 2);
+
+       // list.delete(2);
+
+        System.out.println(list.toString());
+    }
+
+}
\ No newline at end of file