24. 两两交换链表中的节点

 非递归解法

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode pre = new ListNode(0);
        pre.next = head;
        ListNode temp = pre;
        while(temp.next != null && temp.next.next != null) {
            ListNode start = temp.next;
            ListNode end = temp.next.next;
            temp.next = end;
            start.next = end.next;
            end.next = start;
            temp = start;
        }
        return pre.next;
    }
}

递归解法

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

26. 删除有序数组中的重复项

class Solution {
    public int removeDuplicates(int[] nums) {
    if(nums == null || nums.length == 0) return 0;
    int p = 0;
    int q = 1;
    while(q < nums.length){
        if(nums[p] != nums[q]){
            // 在他俩之间有间隔才复制值
            if(q - p > 1){
                nums[p + 1] = nums[q];
                }
            p++;
            }
        q++;
        }
    return p + 1;
    }
}

 27. 移除元素

 只遍历一次数组的解法

class Solution {
    public int removeElement(int[] nums, int val) {
        int i = 0;
        int j = nums.length - 1;
        while (i <= j) {
            // 左边有相同值 把右边的值赋给它 否则 左边索引加加
            if (nums[i] == val) {
                nums[i] = nums[j];
                j--;
            } else {
                i++;
            }
        }
        return i;
    }
}

28. 找出字符串中第一个匹配项的下标 ⭐

 KMP算法框架:如果已经匹配的字符串包含相同的前缀和后缀，遇到下一个不匹配的位置时，指向模式串的指针跳转到前缀的后一个位置，还是不匹配的话，再往前跳转后继续比较；先构造一个next数组来记录模式串指针跳转的位置

// s[]是长文本，p[]是模式串，n是s的长度，m是p的长度
求模式串的Next数组：
for (int i = 1, j = 0; i < m; i ++ )
{
    while (j && p[i] != p[j]) j = ne[j-1];
    if (p[i] == p[j]) j ++ ;
    ne[i] = j;
}

// 匹配
for (int i = 0, j = 0; i < n; i ++ )
{
    while (j && s[i] != p[j]) j = ne[j-1];
    if (s[i] == p[j]) j ++ ;
    if (j == m)
    {
        // 匹配成功后的逻辑
        // 比如返回下标
        return i - m + 1;
    }
    // 没找到 
    return -1;
}

完整代码

class Solution {
    public int strStr(String haystack, String needle) {
        // KMP算法
        int n=haystack.length(), m=needle.length();
        if(m==0) return 0;
        // 先构造next数组，next数组中的元素表示当前两个元素不匹配时，needle指针要跳转的位置
        // haystack: [a, b, e, a, b, a, b, e, a, b, f]  // 主串
        // needle:   [a, b, e, a, b, f]             // 模式串 子串
        // next:     [0, 0, 0, 1, 2, 0]
         int[] next = new int[m];
        for(int i=1,j=0; i<m; i++){
            while(j>0 && needle.charAt(i)!=needle.charAt(j)) 
        // 一直和前一位置的值比较，直到遇到相等的字符或者j=0；j通过next[j-1]来回退
                j = next[j-1];
            if(needle.charAt(i)==needle.charAt(j)) j++;
            next[i] = j;
        }
        
        // 利用next数组进行跳转匹配，不再需要回退haystack的指针i
        for(int i=0,j=0; i<n; i++){
            // 匹配不成功，needle指针j回退并继续比较
            while(j>0 && haystack.charAt(i)!=needle.charAt(j))
                j = next[j-1];  
            if(haystack.charAt(i)==needle.charAt(j)) j++;
            if(j==m) return i - m + 1;
        }
        return -1;
    }
}