1.連結串列結構

2.自定義連結串列（加深對連結串列結構的理解）

連結串列結構

　　元素可以隨機分佈在記憶體的任何地方

　　通過引用將元素關聯起來

　　由於連結串列在進行插入和刪除操作的時候，只需要改變指標的指向，不需要移動資料

　　在插入和刪除操作的效能上要高於陣列操作

　　陣列的查詢操作效能要高於連結串列（陣列可以通過下標索引）

　　如果一組陣列經常用來做查詢操作，較少做插入或刪除操作，就用陣列

　　如果一組資料經常需要插入或刪除，就用連結串列

定義連結串列結點類

 private class Node{
        private Object obj;//結點中的元素
        private
 
 Node next;//對下一個結點的引用

        //過載構造方法，要求建立結點物件的時候必須要傳入元素
        public Node(Object obj){
            this.obj = obj;
        }

        @Override
        public String toString() {
            return obj.toString();
        }
    }

定義MyLinkListl類 //自定義連結串列

//定義一個空連結串列，頭結點為null的連結串列就是空連結串列
    private
 
 Node head=null;
    private Node last=null;//空連結串列的尾結點也是null
    private int count=0;//元素個數計數器

新增元素

 public void add(Object obj){

//先將元素封裝成一個結點物件
        Node n = new Node(obj);

        //如果是空連結串列，新的結點就是連結串列的第一個結點
        //這個結點既是頭結點，也是尾結點
        if(head==null){
            head=n;
        }else {
            
 
//將尾結點的next指向新的結點
            last.next = n;
        }
        //將last指向新的尾結點
        last = n;

        count++;

    }

插入資料的方法
index 指定位置
obj   插入元素

public void insert(int index,Object obj){
        //將資料封裝成一個結點
        Node newNode = new Node(obj);

        //要將插入到第一個位置，就是要將新結點作為頭結點
        if(index==0){
            newNode.next=head;
            head=newNode;
        }else if(index==count){
            //新節點作為新的尾結點
            last.next=newNode;
            last=newNode;
        }else{
            //要插入的位置的結點
            Node n = getNode(index);
            //要插入位置的前一個結點
            Node n1 = getNode(index - 1);

            n1.next = newNode;
            newNode.next = n;
        }
        count++;
    }

刪除指定位置結點

 public Object delete(int index){
        Node removeNode=null;
        //刪除頭結點
        if(index==0){
            //用一個新的變數指向頭結點
            Node n = head;
            //將head的下一個結點作為新的頭結點
            head= head.next;
            //將n的next指向null
            n.next=null;

            removeNode =n;

        }else if(index==count-1){
            //如果要刪除的是尾結點
            removeNode =last;

            //獲得尾結點的前一個結點
            Node n = getNode(index-1);
            //將last指向n結點
            last = n;
            //將last的next指向null
            last.next=null;


        }else {
            Node n1 = getNode(index - 1);
            Node n2 = getNode(index);
            Node n3 = getNode(index + 1);
            //將前一個結點的next指向後一個節點
            n1.next = n3;
            //將當前結點的next指向null
            n2.next = null;

            removeNode =n2;

        }
        //元素個數計數器--
        count--;

        return removeNode.obj;
    }

根據元素名稱刪除

public void delete(Object obj){
        for(int i=0;i<count;i++) {
            Object o = get(i);
            if (o.equals(obj)) {
                delete(i);
                break;
            }
        }
    }

修改

    public void modify(int index,Object newObj){
        Node n = getNode(index);
        n.obj = newObj;

    }

獲得指定位置引獲得元素

屬性私有化

private Node getNode(int index){
        if(index<0||index>=count){
            throw new IndexOutOfBoundsException("下標越界,size:"+count+",index:"+index);
        }

        int num=0;
        Node  n = head;
        //當num<index的時候，就不停的找下一個結點，每找一次，num++
        //當num==index的時候，此時的結點n就是我們要找的結點
        while(num<index){
            n = n.next;
            num++;
        }

        return n;
    }


    public void getAllNode(){
        //用一個臨時變量表示連結串列
       Node n = head;

       while(n!=null){
           System.out.println(n);
           n = n.next;
       }

    }