用java实现双向链表的增删改查。2021-09-08

用java实现双向链表的增删改查

package homework2.linkedlist;

public class MyLinkedList3<E> {
    //代表链表中的第一个节点
    private Node<E> first;
    //代表链表中的最后一个节点
    private Node<E> last;
    //链表的长度
    private int size = 0;

    public int size() {
        return size;
    }

    //依次添加元素
    public void add(E e) {
        //设置第一个元素
        if (first == null) {
            Node<E> current = new Node<E>(null, e, null);
            first = current;
            last = current;
        } else {
            //新元素的头节点是前一个节点的尾节点，
            Node<E> current = new Node<E>(last, e, null);
            //新元素的头结点
            last.next = current;
            //新元素的尾节点
            last = current;
        }
        //长度加一
        size++;
    }

    //指定位置添加元素
    public void add(int index, E e) {
        //获取要插入位置的索引
        Node<E> old = getNode(index);
        final Node<E> prev = old.prev;
        Node<E> current = new Node<E>(prev, e, old);
        old.prev = current;
        if (prev == null) {
            first = current;
        } else {
            prev.next = current;
        }
        size++;
    }

    //获取链表节点中的元素值
    public E get(int index) {
        return getNode(index).item;
    }

    //更新链表节点中的元素值
    public void update(int index, E e) {
        Node<E> presentNode = getNode(index);
        //获取当前节点的值并替换
        presentNode.item = e;
    }

    //删除某个节点
    public void delete(int index) {
        //获取要删除节点的索引
        Node<E> presentNode = getNode(index);
        //删除头结点，尾节点，其他节点
        if (presentNode.prev == null) {
            first = presentNode.next;
            first.prev = null;
        } else if (presentNode.next == null) {
            last = presentNode.prev;
            last.next = null;
        } else {
            presentNode.prev.next = presentNode.next;
        }
        size--;
    }

    //获取某个节点
    public Node<E> getNode(int index) {
        Node<E> temp = first;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    //定义节点
    private static class Node<E> {
        E item;      //节点值
        Node<E> next;//后继
        Node<E> prev;//前驱

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

测试类：

package homework2.linkedlist;
//测试类
public class LinkedListTest {
    public static void main(String[] args) {
        MyLinkedList3<Integer> list3=new MyLinkedList3<Integer>();
        list3.add(1);
        list3.add(2);
        list3.add(3);
        list3.add(4);
        list3.add(5);
        list3.add(6);
        list3.delete(4);
        for (int i = 0; i < list3.size(); i++) {
            System.out.println(list3.get(i));
        }
    }
}