第四次总结 链表

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;
       }

    }