数据结构与算法线性表及应用--手写双向链表(java)

线性表

线性表（List）：由零个或多个数据元素组成的有限序列。

补充说明:

1>线性表是一个序列。

2>0个元素构成的线性表是空表。

3>线性表中的第一个元素无前驱，最后一个元素无后继，其他元素有且只有一个前驱和后继。

4>线性表是有长度的，其长度就是元素个数，且线性表的元素个数是有限的，也就是说，线性表的长度是有限的。

结构

线性表存储结构有2种，分别是顺序存储和链性存储结构。

顺序存储结构:

链式存储结构:

应用

顺序结构

优点:尾插效率高,支持随机访问。

缺点:中间插入或删除效率低。

应用:ArrayList,数组。

链式结构

优点:中间插入或删除效率高。

缺点:1>没有解决连续存储分配带来的表长。

         2>难以确定的问题失去了顺序存储结构随机存取的特性。

应用:单向链表、双向链表。

此处,讲解下双向链表,单向链表同理。

原理图:

说明:又图可知,双向链表有前后两个指针的指向,前驱指向后继,还有后继指向前驱。

1.定义内部节点类:

    /**
     * 定义节点来
     * @param <E> 
     */
    private static class Node<E> {
        Node<E> prev;    //前驱
        Node<E> next;    //后继
        E item;          //数据

        public Node(Node<E> prev, E item, Node<E> next) {
            this.prev = prev;
            this.next = next;
            this.item = item;
        }
    }

2.定义头节点,尾节点还有链表大小:

 /*
    * 定义头节点 尾节点
    * */
    Node<E> first;
    Node<E> last;
    int size;

3.add方法,默认添加数据是从链表尾部添加,add():

    /**
     * 添加数据在最后
     * @param e
     */
    public void add(E e) {
        linkLast(e);
    }

    /**
     * 添加到最后
     * @param e
     */
    private void linkLast(E e) {
        Node<E> newNode = new Node<E>(last, e, null);  //创建新的节点指向原来最后一个节点
        Node<E> l = last;
        last=newNode;//将创建的新节点定义为尾节点

        if(l==null){   //判断链表中是否已存在节点,可以通过判断原有的最后一个结点
            first=newNode;  //没有存在节点,将新的节点定位头节点
        }else {
            l.next = newNode;  //已经存在节点
        }
        size++;   //链表增加
    }

4.get方法,通过索引得到需要的元素,双向链表好处是可以快速定位节点,通过前后两段定位,get(int index):

    /**
     * 根据索引获取元素
     * @param index
     * @return
     */
    public E get(int index){
        if(index < 0 || index > size){
            return null;
        }
        return node(index).item;
    }
    //获取节点
    private Node<E> node(int index) {   //根据索引定位节点
        if(index < (size >> 1)){ //链表前半部分
            Node<E> node = first;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            return node;
        }else{//链表后半部分
            Node<E> node = this.last;
            for (int i = size-1; i > index; i--) {
                node = node.prev;
            }
            return node;
        }
    }

5.根据索引位置插入数据.add(int index,E e):

    /**
     * 根据索引增加元素
     * @param index
     * @param e
     */
    public void add(int index,E e){
        if(index < 0 || index > size){
            return;
        }
        if(index == size){ //从尾节点插入元素
            linkLast(e);
        }else{  //任意位置插入元素
            Node<E> target = node(index); //获取当前节点
            Node<E> pre = target.prev;//当前节点的前驱
            Node<E> newNode = new Node<>(pre, e, target); //创建节点 当前节点变为新节点的h后继  指向前驱和后继(target)
            //判断是否有前驱
            if(pre == null){ //没有前驱
                first = newNode;
            }else{ //有前驱
                pre.next = newNode;
                target.prev = newNode;
            }
            size++;
        }
    }

6.移除链表中的元素,remove:

   /**
     * 根据索引移除元素
     * @param index
     */
    public void remove(int index){
        if(index < 0 || index > size){
            return;
        }
        Node<E> node = node(index);
        unlinkNode(node);
    }

    private void unlinkNode(Node<E> target) {
        Node<E> pre = target.prev;
        Node<E> next = target.next;
        if(pre == null){
            first = target.next;
        }else{
            pre.next = target.next;
        }
        if(next == null){
            last = target.prev;
        }else{
            next.prev = target.prev;
        }
        size--;
    }

大致的双向链表操作就是这个思路,单向链表思路与该思路差不多,定义节点只需要定义数据+next node。

最后来全部代码:

/**
 * Created by AndyLin on 2018/12/07.
 */

public class LinkedList<E> {
    /**
     * 结点
     */
    private static class Node<E> {
        E item;
        Node<E> prev;
        Node<E> next;

        public Node(Node<E> prev, E item, Node<E> next) {
            this.item = item;
            this.prev = prev;
            this.next = next;
        }
    }

    public LinkedList() {

    }

    //头节点
    Node<E> first;
    //尾节点
    Node<E> last;
    //大小
    int size;

    /**
     * 添加数据在最后
     */
    public void add(E e) {
        linkLast(e);
    }

    /**
     * 添加到最后
     * @param e
     */
    private void linkLast(E e) {
        Node<E> newNode = new Node<E>(last, e, null);
        Node<E> l = last;
        last=newNode;

        if(l==null){
            first=newNode;
        }else {
            l.next = newNode;
        }
        size++;
    }
    /**
     * 查找位置
     */
    public E get(int index){
        if(index<0 || index>size){
            return null;
        }
        return node(index).item;
    }
    /**
     * 获取index位置上的节点
     */
    private Node<E> node(int index){

        //如果index在整个链表的前半部分
        if(index<(size>>1)){   //1000 100   10
            Node<E> node=first;
            for (int i = 0; i < index; i++) {
                node=node.next;
            }
            return node;
        }else{
            Node<E> node=last;
            for (int i = size-1; i > index; i--) {
                node=node.prev;
            }
            return node;
        }


    }

    /**
     * 添加数据在index位置
     */
    public void add(int index,E e) {
        if(index<0 || index>size){
            return ;
        }
        if(index==size){
            linkLast(e);
        }else{
            Node<E> target=node(index);//  index=2
            Node<E> pre=target.prev;
            Node<E> newNode=new Node<E>(pre,e,target);

            if(pre==null){
                first=newNode;
                target.prev = newNode;//4
            }else {
                pre.next = newNode;//3
                target.prev = newNode;//4
            }
            size++;
        }

    }

    /**
     * 删除元素
     */
    public void remove(int index){
        Node<E> target=node(index);
        unlinkNode(target);
    }

    private void unlinkNode(Node<E> p) {//index=2
        Node<E> pre=p.prev;
        Node<E> next=p.next;
        if(pre==null){
            first=p.next;
        }else{
            pre.next=p.next;
        }
        if(next==null){
            last=p.prev;
        }else{
            next.prev=p.prev;
        }
        size--;
    }

}