链表之设计链表

题目

题意：

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。

• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。

• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。

• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。

• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

解决

static class MyLinkedList<T>{

        private Node<T> headNode;
        private Node<T> tailNode;

        public MyLinkedList() {
        }

        // 返回某个index对应的节点值
        public T get(Integer index){

            Integer replace = 0;
            Integer targetReplace = index+1;
            Node result = null;

            if(targetReplace > size() || targetReplace< 0){
                return null;
            }else {
                Node currentNode =  headNode;
                while (currentNode != null){
                    replace++;
                    // 位置相同则返回
                    if(replace.equals(targetReplace)){
                        result = currentNode;
                        break;
                    }else {
                        // 当前节点往后移动
                        currentNode = currentNode.getNext();
                    }
                }
                return (T)result.getValue();
            }

        }

        // 插入在头部
        public void addAtHead(T val){
            Node<T> newNode = new Node<>();
            newNode.setValue(val);

            // 非正常情况
            if(tailNode == null && headNode == null){
                headNode = newNode;
                tailNode = newNode;
            }else{
                // 正常情况
                newNode.setNext(headNode);
                headNode = newNode;
            }
        }

        // 插入在尾部
        public void addAtTail(T val){
            Node<T> newNode = new Node<>();
            newNode.setValue(val);

            if(tailNode == null){
                tailNode = newNode;
                headNode = newNode;
            }

            tailNode.setNext(newNode);
            tailNode = newNode;
        }


        // 在指定index位置插入
        public void addAtIndex(Integer index,T val){

            if(index+1 > size()){
                return;
            }

            if(index+1 <= 0){
                addAtHead(val);
            }else if(index == size()){
                addAtTail(val);
            }else {
                // 正常index位置插入
                Node<T> newNode = new Node<>();
                newNode.setValue(val);

                // 建立虚拟节点，指定当前位置的前一个节点
                Node<T> virtualNode = new Node<>();
                virtualNode.setValue(null);
                virtualNode.setNext(headNode);

                Integer replace = 0;
                Integer targetReplace = index+1;
                Node currentNode =  headNode;
                while (currentNode != null){
                    replace++;
                    // 位置相同则插入
                    if(replace.equals(targetReplace)){
                        virtualNode.setNext(newNode);
                        newNode.setNext(currentNode);
                        break;
                    }else {
                        // 虚拟节点和当前节点往后移动
                        virtualNode = currentNode;
                        currentNode = currentNode.getNext();
                    }
                }


            }
        }


        // 删除指定index位置的Node
        public void deleteAtIndex(Integer index){

            Integer targetReplace = index+1;
            if(targetReplace > size() || targetReplace<= 0){
                return;
            }else{
                // 建立虚拟节点，指定当前位置的前一个节点
                Node<T> virtualNode = new Node<>();
                virtualNode.setValue(null);
                virtualNode.setNext(headNode);

                Integer replace = 0;
                Node currentNode =  headNode;
                while (currentNode != null){
                    replace++;
                    // 位置相同则删除
                    if(replace.equals(targetReplace)){
                        virtualNode.setNext(currentNode.getNext());
                        break;
                    }else {
                        // 虚拟节点和当前节点往后移动
                        virtualNode = currentNode;
                        currentNode = currentNode.getNext();
                    }
                }
            }
        }


        // 列出所有节点
        public ArrayList list(){
            ArrayList<T> result = new ArrayList<>();

            if(headNode == null){
                return result;
            }

            Node<T> currentNode;
            currentNode = headNode;
            while (currentNode != null){
                result.add(currentNode.getValue());
                currentNode = currentNode.getNext();
            }
            return result;
        }


        // 列出所有节点
        public ArrayList list(Node<T> headNode){
            Node<T> currentNode;
            ArrayList<T> result = new ArrayList<>();

            if(headNode == null){
                return result;
            }
            currentNode = headNode;
            while (currentNode != null){
                result.add(currentNode.getValue());
                currentNode = currentNode.getNext();
            }
            return result;
        }

        // 链表长度
        public Integer size(){
            return list().size();
        }


        // 返回头节点
        public Node<T> getHeadNode(){
            return headNode;
        }

    }

class Node<T>{
    private T value;
    private Node<T> next;


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

    public Node() {
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public Node<T> getNext() {
        return next;
    }

    public void setNext(Node<T> next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                ", next=" + next +
                '}';
    }
}