JAVA数据结构与算法（三）

/**
 * 自己的链表功能
 * 1，最后位置上的新增
 * 2，获取指定位置上元素
 * 3，指定位置上的新增
 * 4，指定位置上的删除
 * @param <T>
 */
public class MyLinkedList<T> {

    /**
     * 节点
     * @param <T>
     */
    public static class Node<T>{
        T item;
        Node<T> prev;
        Node<T> next;

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

    Node<T> first;  //头节点
    Node<T> last;  //尾节点，
    int size;

    public MyLinkedList() {
    }

    /**
     * 在最后添加元素
     * @param t
     */
    public void add(T t){
        addLast(t);
    }

    /**
     * 在最后添加
     * @param t
     */
    private void addLast(T t) {
        //新的前一个节点是当前链表的最后一个节点
        Node<T> newNode = new Node<T>(last, t, null);
        Node<T> l = last;

        //将最后一个节点设置为新增节点
        last = newNode;

        if (null == l){
            first = newNode;
        } else {
            l.next = newNode;
        }

        size++;

    }

    /**
     * 获取第index上的节点上
     * @param index
     * @return
     */
    public T get(int index) {
        if (index < 0 || index > size){
            return null;
        }
        return node(index).item;
    }

    /**
     * 获取第index位置上的节点
     * @param index
     * @return
     */
    private Node<T> node(int index) {
        //判定index是不是在前半部分
        if (index < (size>>1)){
            Node<T> node = first;
            for (int i = 0; i < index; i++){
                node = node.next;
            }
            return node;
        } else {
            Node<T> node = this.last;
            for (int i = size-1; i > index; i--){
                node = node.prev;
            }
            return node;
        }

    }

    /**
     * 在指定索引处添加元素
     * @param index
     * @param t
     */
    public void add(int index, T t){
        if (index < 0 || index > size){
            return;
        }
        if (index == size){
            addLast(t);
        } else {
            //先找到这个位置上对应的节点
            Node<T> target = node(index);
            //找到这个节点的前节点
            Node<T> pre = target.prev;
            //创建一个前面是prev节点的节点
            Node<T> newNode = new Node<>(pre, t, target);

            //如果index = 0,那么prev就是null
            if (0 == index || null == pre){
                first = newNode;
            } else {
                pre.next = newNode;
            }
            target.prev = newNode;
            size++;

        }
    }

    /**
     * 移除某个索引元素
     * @param index
     */
    public void remove(int index){
        //先找到这个位置上对应的节点
        Node<T> target = node(index);
        unLinkNode(target);
    }

    private void unLinkNode(Node<T> target) {
        /**
         * 思想
         * 1，找到前后节点
         * 2，将前后节点连上
         * 2.1，将target的后指针赋予前节点的后指针
         * 2.2将target的前指针赋予后节点的前指针
         */

        // 找到前后节点，
        Node<T> prev = target.prev;
        Node<T> next = target.next;

        // 将前后节点连上
        // 将target的后指针赋予前节点的后指针
        if (null == prev){
            first = target.next;
        } else {
            prev.next = target.next;
        }
        //将target的前指针赋予后节点的前指针
        if (null == next){
            last = target.prev;
        } else {
            next.prev = target.prev;
        }

        size--;
    }

}

 

 

测试代码

@Test
    public void MyLinkedTest(){
        MyLinkedList<Integer> list = new MyLinkedList<>();
        list.add(5);
        list.add(6);
        list.add(4);
        list.add(7);
//        list.add(4, 66);
        list.remove(2);
        for (int i = 0; i < list.size; i++){
            System.out.println(list.get(i).toString());
        }

    }