单向链表增删改查

//单向链表
 
class Test {//(T)void

    public static void main(String[] args) {
        SingleLink<Integer> singleLink = new SingleLink<>();
        singleLink.addHead(2);
        singleLink.addHead(1);//12
        singleLink.addTail(3);//123
        singleLink.addTail(4);//1234
        SingleLink<Integer> link2 = new SingleLink<>();
        link2.addHead(6);
        link2.addHead(5);//56
        link2.addTail(7);//5678
        link2.addTail(8);
       // SingleLink.Node<Integer> head = SingleLink.mergeLIST(singleLink.getHead(), link2.getHead());
        singleLink.getTail().setNext(singleLink.getHead());
       // singleLink.show();
        System.out.println(singleLink.isloop());

      /* // SingleLink.Node<Integer> head = SingleLink.mergeTwo(singleLink, link2);
        for (SingleLink.Node<Integer> p = head; p != null; p = p.getNext()) {
            System.out.print(p.getValue()+" ");
        }*/


}
//单向链表
 public static class SingleLink<T extends Comparable<T>> implements List<T> {
    private Node<T> Head;
    private Node<T> Tail;
    private int size;

    public Node<T> getTail() {
        return Tail;
    }

    public Node<T> getHead() {
        return Head;
    }

    @Override
    public void addHead(T value) {
        Node<T> newNode = new Node<>(value);
        if (Head == null) {
            Head = newNode;
            Tail = newNode;

        } else {
            newNode.next = Head;
            Head = newNode;

        }
        size++;
    }

    @Override
    public void addTail(T value) {
        Node<T> newNode = new Node<T>(value);
        if (size == 0) {
            Head = newNode;
            Tail = newNode;
        } else {
            Tail.next = newNode;
            Tail = newNode;
        }
        size++;

    }

    @Override
    public void deleteHead() {
        if (Head == null) {
            return;
        }
        Head.value = null;//防止内存泄露
        if (size == 1) {
            Head = null;
            Tail = null;

        } else {
            //Head==null;
            Head = Head.next;
        }
        size--;

    }

    @Override
    public void deleteTail() {
        if (size == 0) {
            return;
        }
        Tail.value = null;//防止内存泄漏
        if (size == 1) {
            Head = null;
            Tail = null;
        } else {
            Node<T> P = Head;
            for (; P.next != Tail; P = P.next) {
                ;
            }
            //P.next.value=null//tail=null
            P.next = null;
            Tail = P;
        }
        size--;

    }

    @Override
    public void deleteValue(T value) {
        if (size == 0) {
            return;
        }
        if (Head.value.compareTo(value) == 0) {
            deleteHead();
            deleteValue(value);
        }
        if (size == 1 && Head.value.compareTo(value) != 0) {
            return;
        } else {
            for (Node<T> P = Head; P.next != null; ) {//注意P！=null会出现空指针异常因为当p.next=null时P.next.next就是空指针一张
                if (P.next == Tail) {
                    Tail = P;
                }
                if (P.next.value.compareTo(value) == 0) {
                    P.next.value = null;
                    P.next = P.next.next;
                    size--;
                } else {
                    P = P.next;
                }
            }


        }

    }

    @Override
    public void removeValue(T scrValue, T aimValue) {
        for (Node<T> P = Head; P != null; P = P.next) {
            if (P.value.compareTo(scrValue) == 0) {
                P.value = aimValue;
            }
        }

    }

    @Override
    public boolean contains(T value) {
        for (Node<T> P = Head; P != null; P = P.next) {
            if (P.value.compareTo(value) == 0) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void size() {
        return;


    }

    /*
     *
     * */

    /*
     *
     * */
    static class Node<E> {
        private E value;
        private Node<E> next;

        public Node(E value) {
            this.value = value;

        }

        public E getValue() {
            return value;
        }

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

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

    public void show() {
        //Node<T> node=getEntranceNode();
        for (Node<T> P = Head; P != null; P = P.next) {
            System.out.print(P.value + " ");
        }
    }

    /*
     * 判断是否有环，fast==null,有环，相遇点
     * 两个元素，一个快节点，一个慢节点，如果快结点能追上慢结点 证明有环
     *
     * */
    public Node<T> isLoop() {
        Node<T> fast = Head, slow = Head;
        do {
            if (fast == null || fast.next == null) {
                return null;
            }
            fast = fast.next.next;
            slow = slow.next;

        } while (fast != slow);

        return fast;


    }

    public boolean isloop() {
        //  return  !(isLoop()!=null);
        Node<T> node1 = isLoop();
        if (node1 == null) {
            return false;
        }
        return true;
    }

    /*
     * 有环，环的入口点输出
     * Head-入口点的距离等于相遇点到入口点的距离
     * 两个元素，一个从Head开始跑，一个从相遇点开始跑，两点相遇的位置，即为入口点的位置
     *
     * */
    public Node<T> getEntranceNode() {
        Node<T> meetNode = isLoop(), p = Head, q = meetNode;
        if (meetNode == null) {
            return null;
        }
        while (p != q) {
            p = Head.next;
            q = meetNode.next;
        }
        return meetNode;
    }

    /*
     * 3.逆序单链表，指针反向
     * 三个元素P= Head,Q=P.next;s=P.next.next;
     * 一定注意出现两个连续的next时要防止空指针异常
     * P为空或者p,next为空
     * 维护Head和Tail
     *
     * */
    public SingleLink<T> reverse() {
        if (size == 0 || size == 1) {
            return this;
        }
        Node<T> p = Head, q = p.next, s = p.next.next;
        Head.next = null;//原来的头变成尾巴
        while (q != null) {
            q.next = p;
            p = q;
            q = s;
        }
        if (s != null) {
            s = s.next;
        }
        Head = Tail;
        Head = q;
        return this;
    }

    /*给定两个相交的单向链表，输出出来相交的节点返回
     * 用两个链表的头结点遍历列表，长链表先走完差值，两个链表一起走
     * 值相等时即为相交的节点
     *
     * */
    public Node<T> getIntersectNode(SingleLink<T> link) {//this  link
        if (link == null) {
            return null;
        }
        Node<T> long_node = size > link.size ? this.Head : link.Head;
        Node<T> short_node = size < link.size ? this.Head : link.Head;
        int difference = Math.abs(size - link.size);
        while (difference > 0) {
            long_node = long_node.next;
            difference--;
        }
        while (long_node != short_node) {
            long_node = long_node.next;
            short_node = short_node.next;
        }
        return long_node;
    }

    /*
     *
     *
     *给定两个有序的单向链表，合成一个有序单链表
     *
     *
     * */
    public static <T extends Comparable<T>> Node<T> mergeTwo(SingleLink<T> link1, SingleLink<T> link2) {
        if (link1 == null) return link2.Head;
        if (link2 == null) return link1.Head;
        Node<T> newHead = link1.Head.value.compareTo(link2.Head.value) > 0 ? link2.Head : link1.Head;
        Node<T> p = newHead.next;//p 遍历新链表头节点所在的链表
        Node<T> q = newHead == link1.Head ? link2.Head : link1.Head;
        Node<T> newTail = newHead;
        while (p != null && q != null) {
            if (p.value.compareTo(q.value) > 0) {
                newTail.next = q;//把Head和较小的元素链接起来
                newTail = q;
                q = q.next;
            } else {
                newTail.next = p;
                newTail = p;
                p = p.next;
            }

        }
        if (p == null) {
            newTail.next = q;

        } else {
            newTail.next = p;
        }
        return newHead;
    }

    /*
     * */
    public static <T extends Comparable<T>> Node<T> mergeLIST(Node<T> l1, Node<T> l2) {
        if (l1 == null) return l2;
        if (l2 == null) return l1;
        Node<T> newHead = (l1.value.compareTo(l2.value) > 0) ? l2 : l1;
        Node<T> p = newHead.next;
        Node<T> q = newHead == l1 ? l2 : l1;
        Node<T> tail = newHead;
        while (p != null && q != null) {
            if (p.value.compareTo(q.value) > 0) {
                tail.next = q;//把Head和较小的元素链接起来
                tail = q;
                q = q.next;


            } else {
                tail.next = p;
                tail = p;
                p = p.next;

            }
        }
        if (p == null) {
            tail.next = q;
        } else {
            tail.next = p;
        }
        return newHead;
    }

}}