DS-链表

概述

MyLink

package link;

/**
 * 构建自己的列表
 *
 * @author Deevan
 */
public class MyLink<T> {

    /**
     * 构建节点的数据结构
     * val:数据内容
     * next:指向下一个节点的引用
     */
    private class Node {
        private T val;
        private Node next;

        /**
         * 节点的构造
         *
         * @param val 值
         */
        Node(T val) {
            this.val = val;
            this.next = null;
        }

        @Override
        public String toString() {
            return val.toString();
        }
    }


    private Node head;
    private int size;

    public MyLink() {
        head = null;
    }

    /**
     * 判断链表是否为空
     */
    public boolean isEmpty() {
        return this.size == 0;
    }

    /**
     * 返回链表的长度
     */
    public int getSize() {
        return this.size;
    }

    /**
     * 向尾部添加元素
     */
    public void addTail(T val) {
        Node node = new Node(val);
        if (head == null) {
            head = node;
        } else {
            Node curNode = head;
            while (curNode.next != null) {
                curNode = curNode.next;
            }
            curNode.next = node;
        }
        this.size++;
    }

    /**
     * 向头部添加元素
     */
    public void addHead(T val) {
        Node node = new Node(val);
        node.next = head;
        head = node;
        this.size++;
    }

    /**
     * 在任意位置插入（无虚拟头结点）
     */
    public void add0(T val, int index) {
        Node node = new Node(val);
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("index is error");
        }
        //链表为空
        if (head == null) {
            head = node;
            this.size++;
            return;
        }
        //针对头结点做特殊处理
        if (index == 0) {
            this.addHead(val);
            return;
        }
        Node preNode = head;
        //找到插入节点的上一个节点
        for (int i = 0; i < index - 1; i++) {
            preNode = preNode.next;
        }
        node.next = preNode.next;
        preNode.next = node;
        this.size++;
    }

    /**
     * 通过索引向链表添加元素（增加虚拟头结点）
     */
    public void add(T val, int index) {
        if (index > this.size || index < 0) {
            throw new IllegalArgumentException("index is error");
        }
        Node dummyHead = new Node(null);
        Node node = new Node(val);
        dummyHead.next = head;
        Node preNode = dummyHead;
        for (int i = 0; i < index; i++) {
            preNode = preNode.next;
        }
        node.next = preNode.next;
        preNode.next = node;
        this.size++;
        //更新head
        head = dummyHead.next;
    }

    /**
     * 获取头结点
     */
    public T getFirst() {
        return get(0);
    }

    /**
     * 获取尾结点
     */
    public T getLast() {
        return get(this.size - 1);
    }

    /**
     * 获取指定索引的结点信息
     */
    public T get(int index) {
        if (index < 0 || index > this.size) {
            throw new IllegalArgumentException("index is error");
        }
        Node curNode = head;
        for (int i = 0; i < index; i++) {
            curNode = curNode.next;
        }
        return curNode.val;
    }

    /**
     * 判断链表中是否包含指定的元素
     */
    public boolean isContains(T val) {
        Node curNode = head;
        while (curNode != null && !curNode.val.equals(val)) {
            curNode = curNode.next;
        }
        return curNode != null;
    }

    /**
     * 根据索引更新链表中的结点内容
     */
    public void set(int index, T val) {
        if (index < 0 || index >= this.size) {
            throw new IllegalArgumentException("index is error");
        }
        Node curNode = head;
        for (int i = 0; i < index; i++) {
            curNode = curNode.next;
        }
        curNode.val = val;
    }

    /**
     * 删除头结点
     */
    public T removeFirst() {
        return removeByIndex(0);
    }

    /**
     * 删除尾结点
     */
    public T removeLast() {
        return removeByIndex(this.size - 1);
    }

    /**
     * 删除指定位置的节点
     */
    public T removeByIndex(int index) {
        if (index >= this.size || index < 0) {
            throw new IllegalArgumentException("index is error");
        }
        Node dummyHead = new Node(null);
        dummyHead.next = head;
        Node preNode = dummyHead;
        //找到删除节点的前一个节点
        for (int i = 0; i < index; i++) {
            preNode = preNode.next;
        }
        Node delNode = preNode.next;
        T result = delNode.val;
        preNode.next = delNode.next;
        delNode.next = null;
        this.size--;
        head = dummyHead.next;
        return result;
    }

    /**
     * 根据内容删除
     */
    public void removeByVal(T val) {
        Node dummyHead = new Node(null);
        dummyHead.next = head;
        Node preNode = dummyHead;
        while (preNode.next != null) {
            if (preNode.next.val.equals(val)) {
                //删除
                Node delNode = preNode.next;
                preNode.next = delNode.next;
                delNode.next = null;
                this.size--;
            } else {
                preNode = preNode.next;
            }
            //让头节点指向虚拟头节点的下一个节点：如果删除的节点是头节点，删除之后就只剩下head了，头节点就要改变
            this.head = dummyHead.next;
        }
    }

    /**
     * 使用递归实现删除结点
     */
    public void removeDG(T val) {
        if (this.isEmpty()) {
            return;
        }
        //判断头节点
        if (this.head.val.equals(val)) {
            Node temp = this.head;
            this.head = this.head.next;
            temp.next = null;
            this.size--;
        } else {
            removeDG(head, val);
        }
    }

    private Node removeDG(Node head, T val) {
        // 递归到底的情况:头大节点为空
        if (head == null) {
            return null;
        }
        // 不为空则下一个节点为此函数的递归，再次检测
        head.next = removeDG(head.next, val);
        return head.val == val ? head.next : head;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node curNode = head;
        while (curNode != null) {
            sb.append(curNode + "-->");
            curNode = curNode.next;
        }
        return sb.toString();
    }
}