链表

链表

常见的数据结构，在删除和添加操作上具有良好的性能，但只能通过指针依次进行查找

Java中实现

public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { 
        thsis.val = x;
    }
}

算法中常见的技巧

1. 快慢指针，维护两个不同移速的指针
2. 为空判断，注意在调用next操作之前，始终判断当前节点是否为null，以及在循环条件中仔细定义 为空判断，注意在调用next操作之前，始终判断当前节点是否为null，以及在循环条件中仔细定义
3. 头结点，合适的引用头结点，可以统一进行链表的操作
4. 多指针，在进行处理链表相关算法时候，可以使用多个指针跟踪节点，在多数情况下需要跟踪当前节点的前一节点- 多指针，在进行处理链表相关算法时候，可以使用多个指针跟踪节点，在多数情况下需要跟踪当前节点的前一节点和后一节点
5. 简单测试，通常在完成算法时候，可以通过简单的代入测试样例进行代码跟读，特别注意边界问题简单测试，通常在完成算法时候，可以通过简单的代入测试样例进行代码跟读，特别注意边界问题

环形链表

环形链表

给定一个链表，判断链表中是否有环(https://leetcode-cn.com/problems/linked-list-cycle/)

思路一：哈希表，检查一个节点是否被访问，时间复杂度O(n)，空间复杂度O(n)

public class Solution {
    public boolean hasCycle(ListNode head) {
        Set<ListNode> nodes = new HashSet<ListNode>();
        
        while(head != null){
            if(nodes.contains(head)) //判断是否已经访问
                return true;
            else
                nodes.add(head);
            head = head.next;
        }
        
        return false;
    }
}

思路2：快慢指针，时间复杂度O(n)，空间复杂度O(1)

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head ==null || head.next == null)
            return false;
        
        ListNode slow = head;
        ListNode fast = head;
        
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            
            if(fast == slow)
                return true;
        }
    
        return false;
    }
}

环形链表 II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。环形链表 II

维护两个指针，快指针是慢指针移动速度的两倍，假设链表头节点到环入口距离是a，环 入口到两指针相遇点距离是b，相遇点到环入口距离是c，相遇时绕环的次数k>=1

有如下关系：
2(a+b) = a + b+ (b+c)k
a = c + (b+c)(k-1)

可得到下面结论：
当指针分别从链表头节点和相遇点以相同速度出发，再次相遇时候一定是链表环的入口

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode meetNode = findMeetNode(head);
        if(meetNode == null)
            return null;
        
        while(head != meetNode){
            head = head.next;
            meetNode = meetNode.next;
        }
        
        return meetNode;
    }
    
    private ListNode findMeetNode(ListNode head){
        if(head == null || head.next == null){
            return null;
        }
        
        ListNode slow = head;
        ListNode fast = head;
        
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(fast == slow){
                return fast;
            }       
        }
        
        return null;
    }
 
}

反转链表

反转链表

反转一个单链表 反转链表

思路1:在循环过程中，依次将链表节点插入头节点

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null)
            return null;
                 
        ListNode headNode = null;
        ListNode currNode = head;
        ListNode nextNode = null;
        
        while(currNode != null){
            nextNode = currNode.next;
            currNode.next = headNode;
            headNode = currNode;
            currNode = nextNode;
        }
        
        return headNode;
    }
}

思路二：直接修改指针，指向上一个节点,跟踪上一个节点

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null)
            return null;
        
        ListNode preNode = null;
        ListNode currNode = head;
        ListNode nextNode = null;
        
        while(currNode != null){
            nextNode = currNode.next;
            currNode.next = preNode;
            preNode = currNode;
            currNode = nextNode;
        }
        
        return preNode;
    }
                                      
}

思路三：递归

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null)
            return head;
        
        ListNode node = reverseList(head.next);
        head.next.next = head; 
        head.next = null;
        
        return node;
     }
}

反转链表 II

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。反转链表 II

典型的技巧3(多指针)，找到开始逆置链表的节点，采用上述任一思路进行链表的逆置

class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
           if(head == null)
            return null;

        ListNode result = new ListNode(0);
        result.next = head;               
        ListNode startNode = head;
        ListNode startPreNode = result;

        for(int i=0; i<m-1; i++) {
            startPreNode = head;
            head = head.next;
            startNode = head;
        }

        // 逆置
        ListNode preNode = result;
        ListNode currNode = startNode;
        ListNode nextNode = null;

        for(int i=0; i<= n-m; i++){
            nextNode = currNode.next;
            currNode.next = preNode;
            preNode = currNode;
            currNode = nextNode;
        }

        startNode.next = currNode;
        startPreNode.next = preNode;
        
        return result.next;
    }

}