LeetCode算法学习笔记 - Day4

Java判断环形链表

• 给你一个链表的头节点 head ，判断链表中是否有环。
• 如果链表中存在环，则返回 true 。 否则，返回 false 。

LeetCode的朋友们都是使用快慢双指针的写法来判断的…我感觉没必要啊这样有点低效.来看看我写的方法

	 public boolean hasCycle(){
        Node temp = head; //初始为头结点（是一个移动的指针指向当前遍历的结点）
        while (temp.next != null){ //遍历链表
            temp = temp.next;
            if (temp == head){ //如果当前结点等于头结点就是有环
                return true;
            }
        }
        return false; //没环跑完就退出while返回false
    }

再来看看快慢双指针的写法

public class Solution {
    public boolean hasCycle(ListNode head) {
        //快慢指针 从同一起点走
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next !=null){
            fast =fast.next.next; //快指针走两步
            slow = slow.next; //慢指针走一步
            if(slow==fast){ //快慢指针相遇,证明有环
                return true;
            }
        }
        //否则 无环
        return false;
    }
}

作者：nanasemalu
链接：https://leetcode-cn.com/leetbook/read/linked-list/jbex5/?discussion=nwnrlh
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

经过测试.在10万个结点下我的方法执行时间是4ms.快慢双指针的方法执行时间是6ms
在100万个结点下我的方法执行时间是7ms.快慢双指针的方法执行时间是11ms

但是LeetCode说我这代码运行时间超时，但是在我的IDE上就可以运行，而且比双指针方法快

Java求环形链表入环点

• 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
  一开始是看不懂的，就跟着评论区的代码看一眼写一点，后来多研究了一下就懂了
  (我一直以为环形链表尾结点必须连头结点…其实尾结点可以连头之后的任意结点…)
  如果只是头尾相接的话就没必要有入环点了，因为头就是入环点…我就一直卡在这里

    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast){
                break;
            }
        }
        if (fast == null || fast.next == null){
            return null;
        }
        slow = head;
        while (true){
            if (slow == fast){
                break;
            }
            slow = slow.next;
            fast = fast.next;
        }
        return fast;
}

Java返回相交链表的相交点

• 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

	public Node getIntersectionNode(Node nodeA,Node nodeB){
        int nodeALength = length(nodeA);
        int nodeBLength = length(nodeB);
        Node tempA = nodeA;
        Node tempB = nodeB;
        if (nodeALength == nodeBLength){
            while (tempA != null){
                if (tempA == tempB){
                    return tempA;
                }
                tempA = tempA.next;
                tempB = tempB.next;
            }
        }else {
            if (nodeALength > nodeBLength){
                int length = nodeALength - nodeBLength;
                int i = 0;
                while (i < length){
                    tempA = tempA.next;
                    i++;
                }
                while (tempA != null){
                    if (tempA == tempB){
                        return tempA;
                    }
                    tempA = tempA.next;
                    tempB = tempB.next;
                }
            }else {
                int length = nodeBLength - nodeALength;
                int i = 0;
                while (i < length){
                    tempB = tempB.next;
                    i++;
                }
                while (tempA != null){
                    System.out.println(tempA);
                    System.out.println(tempB);
                    if (tempA == tempB){
                        return tempA;
                    }
                    tempA = tempA.next;
                    tempB = tempB.next;
                }
            }
        }
        return null;
    }
    
    public int length(Node node) {
        int length=0;
        Node temp = node;
        while(temp.next != null){
            length++;
            temp = temp.next;
        }
        return length;
    }

写的很满意~执行时间超过99.98%,内存消耗超过87.76%

删除链表的倒数第N个节点

• 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

    public int length(ListNode node) {
        int length=0;
        ListNode temp = node;
        while(temp.next != null){
            length++;
            temp = temp.next;
        }
        return length;
    }
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode temp = head;
        if (head.next == null){
            return null;
        }
        int length = length(head) - n;
        int i = 0;
        if (length == -1){
            head = head.next;
            return head;
        }
        while (temp != null){
            if (i == length){
                temp.next = temp.next.next;
            }
            i++;
            temp = temp.next;
        }
        return head;
    }
    
写的很满意~执行时间超过100%,内存消耗超过87.10%

Java反转链表

• 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
    public ListNode reverseList(ListNode head) {
        if (head == null){
            return null;
        }
        ListNode temp = head;
        ListNode nowHead = head; //当前头结点
        while (temp.next != null){
            ListNode next = temp.next.next; //得到1的后面第二位 FIRST: 1-2-3-4-5 VAL(3-4-5)   SECOND: 2-1-3-4-5 VAL(4-5)
            temp.next.next = nowHead; //把1后一个数放在头结点前 FIRST: 2-1   SECOND: 3-2-1
            nowHead = temp.next; //当前头结点为1后的一个数
            temp.next = next; //1后面修改为原1的后两位 FIRST: 2-1-3-4-5   SECOND: 3-2-1-4-5   ...以此类推
        }
        return nowHead;
    }

执行时间超过100%，占用内存超过98.54% ...写的时候思路清晰，写完了脑袋就蒙了，写注释的时候就在脑子里把whil跑了一遍哈哈哈人脑计算机

移除链表元素

• 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

    public ListNode removeElements(ListNode head, int val) {
        ListNode temp = head;
        while (temp.val == val){
            temp = temp.next;
            if (temp == null){
                return null;
            }
        }
        while (temp != null){
            if (temp.next.val == val){
                temp.next = temp.next.next;
            }
            temp = temp.next;
        }
        return head;
    }

代码没问题，LeetCode不给过，下面看看递归的写法

	public Node recursion(Node node,int val){
        if (node == null){ //递归到最后一个就返回null
            return null;
        }
        node.next = recursion(node.next,val); //当前结点的下一个为当前结点的下一个的返回值 (当递归到最后一个结点时再次递归就会返	回null,当前节点（当前就是最后结点）的next就等于null)
        return node.data == val ? node.next : node; //如果data == val就返回当前结点的下一个结点 否则返回当前结点
    }

奇偶链表

• 给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。

    public ListNode oddEvenList(ListNode head) {
        if (head == null){
            return null;
        }
        ListNode headA = head;
        ListNode headB = head.next;
        while (headB != null && headB.next != null){
            ListNode nextA = headB.next;
            headB.next = headB.next.next;
            nextA.next = headA.next;
            headA.next = nextA;
            headA = headA.next;
            headB = headB.next;
        }
        return head;
    }

回文链表

• 给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

我的思路是把链表反转后跟原表进行对比，不过这样的话会修改链表结构，解决方法是反转前new个新类存储表
这样不仅效率低而且内存空间发生改变总之就是各种不好（虽然也能实现效果）
这道题最终也是放弃了 （题目网址）