LeetCode 抽空一练 7.4

25. K 个一组翻转链表

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

package com.jiawei.WeekTwo;

import com.jiawei.Utils.ListNode;

public class ReverseKGroup {
	    public ListNode reverseKGroup(ListNode head, int k) {
	        ListNode hair = new ListNode(0);
	        hair.next = head;
	        ListNode pre = hair;

	        while (head != null) {
	            ListNode tail = pre;
	            // 查看剩余部分长度是否大于等于 k
	            for (int i = 0; i < k; ++i) {
	                tail = tail.next;
	                if (tail == null) {
	                    return hair.next;
	                }
	            }
	            ListNode nex = tail.next;
	            ListNode[] reverse = myReverse(head, tail);
	            head = reverse[0];
	            tail = reverse[1];
	            // 把子链表重新接回原链表
	            pre.next = head;
	            tail.next = nex;
	            pre = tail;
	            head = tail.next;
	        }

	        return hair.next;
	    }

	    public ListNode[] myReverse(ListNode head, ListNode tail) {
	        ListNode prev = tail.next;
	        ListNode p = head;
	        while (prev != tail) {
	            ListNode nex = p.next;
	            p.next = prev;
	            prev = p;
	            p = nex;
	        }
	        return new ListNode[]{tail, head};
	    }
}

自己写的时候一开始并没有想到很好的办法，基本上只能暴力解出来了。后来看了题解的思路，重新又写了一遍。本质上来说这个题就是把原来翻转链表给升级了一下，只需要额外拿一个指针去存未处理的链表段头结点就行了。然后为了可以一次性处理所有结点，题解想到给头结点之前再新开一个结点，这个很有意思。

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

package com.jiawei.WeekTwo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ThreeSum {
  public static List<List<Integer>> threeSumZero(int[] nums) {
    // 总时间复杂度：O(n^2)
    List<List<Integer>> ans = new ArrayList<>();
    if (nums == null || nums.length <= 2)
      return ans;

    Arrays.sort(nums); // O(nlogn)

    for (int i = 0; i < nums.length - 2; i++) { // O(n^2)
      if (nums[i] > 0)
        break; // 第一个数大于 0，后面的数都比它大，肯定不成立了
      if (i > 0 && nums[i] == nums[i - 1]) {
        continue; // 去掉重复情况
      }
      int target = -nums[i];
      int left = i + 1, right = nums.length - 1;
      while (left < right) {
        if (nums[left] + nums[right] == target) {
          ans.add(new ArrayList<>(Arrays.asList(nums[i], nums[left], nums[right])));

          left++;
          right--; // 首先无论如何先要进行加减操作,以下同为防止出现重复情况
          while (left < right && nums[left] == nums[left - 1])
            left++;
          while (left < right && nums[right] == nums[right + 1])
            right--;
        } else if (nums[left] + nums[right] < target) {
          left++;
        } else { // nums[left] + nums[right] > target
          right--;
        }
      }
    }
    return ans;
  }

  public static void main(String[] args) {
    int nums[] = {-1, 0, 1, 2, -1, -4};
    System.out.println(threeSumZero(nums));
  }
}

代码类似一轮快排，左右两个指针向中间推进，根据加和情况考虑左右指针移动。值得注意的是为了防止相同的数组出现，在最外层的循环和内层循环中，都设置了判断语句去判断当前元素和前一个元素是否相等。

912. 排序数组

package com.jiawei.WeekTwo;

import java.util.Random;

public class SortArray {
  public static int[] sortArray(int[] nums) {
    randomizedQuicksort(nums, 0, nums.length - 1);
    return nums;
  }

  public static void randomizedQuicksort(int[] nums, int l, int r) {
    if (l < r) {
      int pos = randomizedPartition(nums, l, r);
      randomizedQuicksort(nums, l, pos - 1);
      randomizedQuicksort(nums, pos + 1, r);
    }
  }

  public static int randomizedPartition(int[] nums, int l, int r) {
    int i = new Random().nextInt(r - l + 1) + l; // 随机选一个作为我们的主元
    swap(nums, r, i);
    return partition(nums, l, r);
  }

  public static int partition(int[] nums, int l, int r) {
    int pivot = nums[r];
    int i = l - 1;
    for (int j = l; j <= r - 1; ++j) {
      if (nums[j] <= pivot) {
        i = i + 1;
        swap(nums, i, j);
      }
    }
    swap(nums, i + 1, r);
    return i + 1;
  }

  private static void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
  }

  public static void main(String[] args) {
    int nums[] = {-1, 0, 1, 2, -1, -4};
    for (int i : sortArray(nums)) {
      System.out.println(i);
    }
  }
}

上面是快速排序，也是考得最多的，其他排序在论坛很容易搜到，之后再总结一下吧。

33. 搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

package com.jiawei.WeekTwo;

public class Search {
  public static int search(int[] nums, int target) {
    int n = nums.length;
    if (n == 0) {
      return -1;
    }
    if (n == 1) {
      return nums[0] == target ? 0 : -1;
    }
    int l = 0, r = n - 1;
    while (l <= r) {
      int mid = (l + r) / 2;
      if (nums[mid] == target) {
        return mid;
      }
      if (nums[0] <= nums[mid]) {
        if (nums[0] <= target && target < nums[mid]) {
          r = mid - 1;
        } else {
          l = mid + 1;
        }
      } else {
        if (nums[mid] < target && target <= nums[n - 1]) {
          l = mid + 1;
        } else {
          r = mid - 1;
        }
      }
    }
    return -1;
  }

  public static void main(String[] args) {
    int nums[] = {4, 5, 6, 7, 0, 1, 2};
    System.out.println(search(nums, 6));
  }
}

看到logn的时间复杂度的查询，第一反应就是二分，不过这个二分是改造过得，条件判断的时候不仅要判断和当前元素比大小，还要比较和首尾元素的大小。

来源：力扣（LeetCode）
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。