数据结构与算法---双链表java实现

实现简介

1. 采用了内部类实现Node节点用来存储数据，还用privious指针，和next指针
2. myLinkedList内部使用init方法来进行数据的初始化，包括初始化首尾节点连接首尾节点指针，创建对象的时候调用构造函数执行init方法
3. 本类实现了最基本的增add、insert，删delete，改set，查get 方法，在进行链表操作时会检查数据的合法性当发生数组越界操作不成功返回false，成功返回true

具体实现

public class MyLinkedList<T>{
    private int size;
    private Node<T> head;
    private Node<T> tail;

    /**
     * 无参的构造方法
     * */
    public MyLinkedList() {
        init();
    }


    /**
     * 初始化
     * */
    private void init(){
        size = 0;
        head = new Node<T>(null, null, null);
        tail = new Node<T>(null, head, null);
        head.next = tail;
        tail.privious = head;
    }


    /**
     * 在最末尾增加
     * */
    public boolean add(T data){
        Node<T> node = new Node<T>(data,tail.privious,tail);
        tail.privious.next = node;
        tail.privious = node;
        size++;
        return true;
    }
    /**
     *删除指定位置的元素
     */
    public boolean delete(int index){
        if(index<0||index>=size){
            return false;
        }
        Node<T> node = getNode(index);
        node.privious.next = node.next;
        node.next.privious = node.privious;
        size--;
        return true;
    }
    /**
     * 设置指定位置的元素
     * */
    public boolean set(int index,T data){
        if(index<0|| index>=size){
            return false;
        }
        Node<T> node = getNode(index);
        node.data = data;
        return true;
    }
    /**
     * 获取指定位置的元素
     * */
    public T get(int index){
        return getNode(index).data;

    }

    /**
     * 在指定位置插入元素
     * */
    public  boolean insert(int index , T data){
        Node<T> node = getNode(index);
        Node<T> n = new Node<>(data, node.privious, node);
        node.privious.next = n;
        node.privious = n;
        size++;
        return true;
    }

    /**
     * 该方法用于找到对应下标的节点
     * */
    private Node<T>  getNode(int index){
        Node<T> temp = head.next;
        if(index>=0&&index<size){
            while(temp!=null&&--index>=0){
                temp = temp.next;
            }
        }

        return temp;
    }

    /**
     * 内部节点类
     * */
    private static class Node<T>{
        public T data;
        public Node<T> privious;
        public Node<T> next;

        public Node(T data, Node<T> privious, Node<T> next) {
            this.data = data;
            this.privious = privious;
            this.next = next;
        }

        @Override
        public String toString() {
            return ""+Node.this.data;
        }
    }
    /**
     * 用来测试的主方法
     * */
    public static void main(String[] args) {
        MyLinkedList<Integer> list = new MyLinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.set(1, 5);
        list.insert(0,0);
        Integer i = list.get(0);
        System.out.println(i);

    }
}