2021-01-24

Java链表的相关操作，拓展快慢指针判断链表是否有环，反转单链表

1、链表添加元素

 public boolean addNode(String str){
        Node node = new Node(str,null);
        // 链表为空
        if(top==null){
            top=node;
            size++;
            return true;
    }
    // 执行到此时链表不为空，设置指针变量指向表头
        Node mid = top;
        while(mid.next != null){
           mid = mid.next; // 遍历
        }
        mid.next = node;  // 添加
        size++;
            return true;
    }

2、链表删除元素，下标删除

public String remove1(int index){
        // 删除头节点
        if(index==0){
            String oldValue = top.value;
            top = top.next;
            size--;
            return oldValue;
        }
        // 删除其他元素
        Node mid = top;
        int target = 1;
        while(target != index){
            mid = mid.next;
            target++;
        }
        String oldValue = mid.next.value;
        mid.next = mid.next.next;
        size--;
        return oldValue;
    }

3、链表按值删除

  public String remove2(String str){
            // 删除的是头节点的内容
        if(str.equals(top.value)){
            top = top.next;
            size--;
            return str;
        }
        Node mid = top;
        // 删除不是头节点，遍历剩余内容，mid的下一个节点不能为空且mid的next的Value不等于str
        while (mid.next != null && ! mid.next.value.equals(str)){

            mid = mid.next;
        }
        // while循环跳出的两种可能，mid的next为null或者两个值相等
        if(mid.next==null){
            return "false";
        }
        String oldValue = mid.next.value;
        mid.next = mid.next.next;
        size--;
        return oldValue;
    }

4、链表查找内容，索引查找

   /*
    按照索引查找，返回值
     */
    public String find(int index){
        int tag = 0;
        Node mid = top;
        while (tag != index){
            mid = mid.next;
            tag++;
        }
        return mid.value;
    }

5、按值查找

/*
返回下标
 */
    public int find(String str){

        Node mid = top;
        int tag = 0;
        while (mid.next != null && !mid.value.equals(str)){
            mid = mid.next;
            tag++;
        }
        if (mid == null){
            return -1;
        }
        return tag;
    }

6、拓展
1）快慢指针找到中间结点

  // 快慢指针找到中间结点
    public String findMid(){
        Node quick  = top;
        Node slow = top;
        while (quick.next != null && quick.next.next !=null){
            quick = quick.next.next;
            slow = slow.next;
        }
        return slow.value;
}

2）快慢指针判断链表是否存在环

// 快慢指针判断是否有环
    public boolean findCircle(){
        Node quick  = top;
        Node slow = top;
        while (quick.next != null && quick.next.next !=null){
            quick = quick.next.next;
            slow = slow.next;
     // 不存在快指针跳过慢指针的情况，若有环，慢指针最多在环内一圈和快指针相遇       
            if(quick == slow)
                return true;
        }

        // 走到这一步,代表没有环
        if(quick.next != null || quick.next.next !=null)
            return false;
        return false;
    }

3）若存在环，找到环的入口

 public static void circle(Node node5) {
        Node quick = node5;
        Node slow = node5;
        while (quick.next !=null && quick.next.next !=null){
            quick = quick.next.next;
            slow = slow.next;
            // 若两指针相遇，跳出循环，让快指针回到出发点，与相遇点的慢指针一起向前移动，此时每次只移动1，两者再次相遇的为环的入口
            if(quick == slow){
                break;
            }
        }
        quick = node5;
        while (quick != slow){
            quick = quick.next;
            slow = slow.next;
        }
        System.out.println(quick.value);
    }

7、反转单链表

public static void relinked(Node linked) {
        // 创建新的链表指向null
        Node relinked = null;
        // 遍历替换，头插法
        while (linked.next !=null){
            // 临时指针指向linked.next,防止链表丢失
            Node linkedNext = linked.next;
            // linked的next指向relinked
            linked.next = relinked;
            relinked = linked;
            linked = linkedNext;
        }
        // 原结点的最后一个结点的next指向空，需要继续处理
        linked.next = relinked;
        relinked = linked;
        System.out.println(relinked);
    }

只是方法，测试类很简单，不在这里挪列，链表的添加、删除等都需要重写toString()方法。参数判断没有写完整。其他都应该没有问题，欢迎指正。指正咨询qq：1286809372