【*M】leetcode-75. 颜色分类

package com.leetcode.medium;

import java.util.Arrays;

/*
 * 给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地对它们进行排序，
 * 使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
 * 我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。必须在不使用库的sort函数的情况下解决这个问题。
 * 示例 1：
 * 
 * 输入：nums = [2,0,2,1,1,0]
 * 输出：[0,0,1,1,2,2]
 * 
 * 示例 2：
 * 
 * 输入：nums = [2,0,1]
 * 输出：[0,1,2]
 * 
 * 
 * 提示：
 * 
 *     n == nums.length
 *     1 <= n <= 300
 *     nums[i] 为 0、1 或 2
 * 
 * 
 * 进阶：
 * 
 *     你可以不使用代码库中的排序函数来解决这道题吗？
 *     你能想出一个仅使用常数空间的一趟扫描算法吗？
 *     来源：力扣（LeetCode）
 *链接：https://leetcode.cn/problems/sort-colors
 *著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */
public class Hot075_sortColors {

	// -----------------------------------Solution1:单指针----------------------------------
	/*
	 * 方法一：单指针
	 * 
	 * 思路与算法
	 * 
	 * 我们可以考虑对数组进行两次遍历。在第一次遍历中，我们将数组中所有的 0 交换到数组的头部。在第二次遍历中，我们将数组中所有的 1 交换到头部的 0
	 * 之后。此时，所有的 2 都出现在数组的尾部，这样我们就完成了排序。
	 * 
	 * 具体地，我们使用一个指针 ptr 表示「头部」的范围，ptr 中存储了一个整数，表示数组 nums 从位置 0 到位置 ptr−1 都属于「头部」。ptr
	 * 的初始值为 0，表示还没有数处于「头部」。
	 * 
	 * 在第一次遍历中，我们从左向右遍历整个数组，如果找到了 0，那么就需要将 0
	 * 与「头部」位置的元素进行交换，并将「头部」向后扩充一个位置。在遍历结束之后，所有的 0 都被交换到「头部」的范围，并且「头部」只包含 0。
	 * 
	 * 在第二次遍历中，我们从「头部」开始，从左向右遍历整个数组，如果找到了 1，那么就需要将 1
	 * 与「头部」位置的元素进行交换，并将「头部」向后扩充一个位置。在遍历结束之后，所有的 1 都被交换到「头部」的范围，并且都在 0 之后，此时 2
	 * 只出现在「头部」之外的位置，因此排序完成。
	 * 
	 * 时间复杂度：O(n)，其中 n 是数组 nums 的长度。 空间复杂度：O(1)。
	 */
	public void sortColors1(int[] nums) {
		int ptr = 0;
		for (int i = 0; i < nums.length; i++)
			if (nums[i] == 0)
				swap(nums, i, ptr++);
		for (int i = ptr; i < nums.length; i++)
			if (nums[i] == 1)
				swap(nums, i, ptr++);
	}

	// -----------------------------------Solution2:双指针----------------------------------
	/*
	 * 方法一需要进行两次遍历，那么我们是否可以仅使用一次遍历呢？我们可以额外使用一个指针，即使用两个指针分别用来交换 0 和 1。
	 * 
	 * 具体地，我们用指针 p0 来交换 0，p1​ 来交换 1，初始值都为 0。当我们从左向右遍历整个数组时：
	 * 
	 * 如果找到了 1，那么将其与 nums[p1]进行交换，并将 p1向后移动一个位置，这与方法一是相同的；
	 * 
	 * 如果找到了 0，那么将其与 nums 进行交换，并将 p0​ 向后移动一个位置。这样做是正确的吗？我们可以注意到，因为连续的 0 之后是连续的
	 * 1，因此如果我们将 0 与 nums[p0] 进行交换，那么我们可能会把一个 1 交换出去。当 p0​<p1​ 时，我们已经将一些 1 连续地放在头部，
	 * 此时一定会把一个 1 交换出去，导致答案错误。因此，如果 p0<p1​，那么我们需要再将 nums[i] 与 nums[p1] 进行交换，其中
	 * i是当前遍历到的位置，在进行了第一次交换后，nums[i] 的值为 1，我们需要将这个 1 放到「头部」的末端。在最后，无论是否有
	 * p0<p1​，我们需要将 p0​ 和 p1​ 均向后移动一个位置，而不是仅将 p0 向后移动一个位置。
	 * 
	 * 时间复杂度：O(n)，其中 n 是数组 nums 的长度。 空间复杂度：O(1)。
	 */
	public void sortColors2(int[] nums) {
		int p0 = 0, p1 = 0;
		for (int i = 0; i < nums.length; ++i) {
			if (nums[i] == 1)
				swap(nums, i, p1++);
			else if (nums[i] == 0) {
				swap(nums, i, p0);
				if (p0 < p1) {
					swap(nums, i, p1);
				}
				++p0;
				++p1;
			}
		}
	}

	// -----------------------------------Solution3:双指针----------------------------------
	/*
	 * 与方法二类似，我们也可以考虑使用指针 p0​ 来交换 0，p2 来交换 2。此时，p0 的初始值仍然为 0，而 p2​ 的初始值为
	 * n−1。在遍历的过程中，我们需要找出所有的 0 交换至数组的头部，并且找出所有的 2 交换至数组的尾部。 由于此时其中一个指针 p2
	 * 是从右向左移动的，因此当我们在从左向右遍历整个数组时，如果遍历到的位置超过了 p2，那么就可以直接停止遍历了。
	 * 具体地，我们从左向右遍历整个数组，设当前遍历到的位置为 i，对应的元素为 nums[i]；
	 * 
	 * 如果找到了 0，那么与前面两种方法类似，将其与 nums[p0] 进行交换，并将 p0 向后移动一个位置； 如果找到了 2，那么将其与 nums[p2]
	 * 进行交换，并将 p2​ 向前移动一个位置。
	 * 
	 * 这样做是正确的吗？可以发现，对于第二种情况，当我们将 nums[i] 与 nums[p2] 进行交换之后，新的 nums[i] 可能仍然是 2，也可能是
	 * 0。然而此时我们已经结束了交换，开始遍历下一个元素 nums[i+1]，不会再考虑 nums[i] 了，这样我们就会得到错误的答案。
	 * 
	 * 因此，当我们找到 2 时，我们需要不断地将其与 nums[p2] 进行交换，直到新的 nums[i] 不为 2。此时，如果 nums[i] 为
	 * 0，那么对应着第一种情况；如果 nums[i] 为 1，那么就不需要进行任何后续的操作。 时间复杂度：O(n)，其中 n 是数组 nums 的长度。
	 * 空间复杂度：O(1)。
	 */
	public void sortColors3(int[] nums) {
		int p0 = 0, p2 = nums.length - 1;
		for (int i = 0; i < p2; ++i) {
			while (i <= p2 && nums[i] == 2)
				swap(nums, i, p2--);
			if (nums[i] == 0)
				swap(nums, i, p0++);
		}
	}

	public void sortColors4(int[] arr) {
		int L = -1, R = arr.length;
		for (int i = 0; i < R;) {
			if (arr[i] < 1)
				swap(arr, i, 1 + L++);
			else if (arr[i] > 1)
				swap(arr, i--, R-- - 1);
			i++;
		}
	}

	// -------------------------swap--------------------------------
	private void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	// -------------------------main--------------------------------
	public static void main(String[] args) {
		int[] arr = { 0, 1, 1, 2, 2, 0, 1, 0, 2, 1, 1, 0, 1 };
		Hot075_sortColors instance = new Hot075_sortColors();
		instance.sortColors3(arr);
		Arrays.stream(arr).forEach(System.out::println);
		//
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 2;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = toPositiveNumber(generateRandomArray(maxSize, maxValue));
			int[] arr2 = copyArray(arr1);
			instance.sortColors2(arr1);
			Arrays.sort(arr2);
			if (!isEqual(arr1, arr2)) {
				// 打印arr1
				System.out.println(Arrays.toString(arr1));
				// 打印arr2
				System.out.println(Arrays.toString(arr2));
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking!");
	}

	// -----------------------------------for-test----------------------------------
	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		// Math.random() -> [0,1) 所有的小数，等概率返回一个
		// Math.random() * N -> [0,N) 所有的小数，等概率返回一个
		// (int)Math.random() -> [0,N-1] 所有的整数，等概率返回一个
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())]; // 长度随机
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}
	
	public static int[] toPositiveNumber(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] > 0 ? arr[i] : -arr[i];
        }
        return arr;
    }

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i] + " ");
		}
		System.out.println();
	}
}