单链表常见操作(添加，删除，判断是否有环)

package com.wqjsmile.leetcode;

public class lianbiaoyouhuan {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        int[] array = new int[]{3, 2, 0, -4};
        int pos = 1;//指定末尾节点指向哪个节点，如果为-1，则表示指向空
        //添加链表结点
        for (int i = 0; i < array.length; i++) {
            myLinkedList.addNode(array[i]);
        }

        //打印链表
        myLinkedList.printLink();

        //判断链表是否有环
        boolean isRinged = myLinkedList.isRinged();
        System.out.println("链表是否有环：" + isRinged);

        //将链表的最后一个结点指向头结点，制造有环的效果
        Node lastNode = myLinkedList.getLastNode();
        if (pos != -1) {
            Node posNode = myLinkedList.head;
            for (int i = 0; i < pos; i++) {
                posNode = posNode.next;
            }

            lastNode.next = posNode;
            isRinged = myLinkedList.isRinged();
            System.out.println("链表是否有环：" + isRinged);
        }else{
            System.out.println("链表是否有环：" + isRinged);
        }
    }
}

/**
 * 链表结点的实体类
 *
 *
 */
class Node {
    Node next = null;//下一个结点
    int data;//结点数据
    public Node(int data){
        this.data = data;
    }
}


class MyLinkedList {

    /**
     * 链表的头结点
     */
    Node head = null;

    /**
     * 链表添加结点:
     * 找到链表的末尾结点，把新添加的数据作为末尾结点的后续结点
     *
     * @param data
     */
    public void addNode(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = newNode;
    }

    /**
     * 链表删除结点:
     * 把要删除结点的前结点指向要删除结点的后结点，即直接跳过待删除结点
     *
     * @param index
     * @return
     */
    public boolean deleteNode(int index) {
        if (index < 1 || index > length()) {//待删除结点不存在
            return false;
        }
        if (index == 1) {//删除头结点
            head = head.next;
            return true;
        }
        Node preNode = head;
        Node curNode = preNode.next;
        int i = 2;
        while (curNode != null) {
            if (i == index) {//寻找到待删除结点
                preNode.next = curNode.next;//待删除结点的前结点指向待删除结点的后结点
                return true;
            }
            //当先结点和前结点同时向后移
            preNode = preNode.next;
            curNode = curNode.next;
            i++;
        }
        return true;
    }

    /**
     * 求链表的长度
     *
     * @return
     */
    public int length() {
        int length = 0;
        Node curNode = head;
        while (curNode != null) {
            length++;
            curNode = curNode.next;
        }
        return length;
    }

    /**
     * 判断链表是否有环：
     * 设置快指针和慢指针，慢指针每次走一步，快指针每次走两步
     * 当快指针与慢指针相等时，就说明该链表有环
     */
    public boolean isRinged() {
        if (head == null) {
            return false;
        }
        Node slow = head;
        Node fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (fast == slow) {
                return true;
            }
        }
        return false;
    }

    /**
     * 打印结点
     */
    public void printLink(){
        Node curNode = head;
        while(curNode !=null){
            System.out.print(curNode.data);
            curNode = curNode.next;
            if(curNode !=null){
                System.out.print("-->");
            }
        }
        System.out.println();
    }

    /**
     * 返回链表的最后一个结点
     */
    public Node getLastNode(){
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
        }
        return temp;
    }
}

输出：

3-->2-->0-->-4
链表是否有环：false
链表是否有环：true