剑指offer——11.旋转数组的最小数字

题目：

题1：实现快速排序

题2：年龄排序问题。

题3：旋转数组的最小数字

知识点：

1. 快速排序算法，参考：https://blog.csdn.net/shujuelin/article/details/82423852
2. 创建指定大小的数组（居然忘了，笨噢!）：int[] timesofAge = new int [100];
3. arr1 = [1,2,3,4,5,6]; 对应出现次数arr2 = [0,0,2,3,2,1],存放在另一个数组中用2次循环（1分钟内快速写出！）

注意：

1. 思考要全面！！！（旋转数组的最小值中多种情况）

代码实现：

package jzoffer;

import java.util.Arrays;

public class Num11 {

	public static void main(String[] args) {
		// 年龄排序
		// int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
		// ageSort(arr, arr.length);
		// 快速排序
		// quickSort(arr, 0, arr.length-1);

		// 旋转数组的最小数字
		int[] arr = { 1, 0, 1, 1, 1 };
		int a = findMin(arr);
		System.out.println(a);
	}

	// 快速排序
	public static void quickSort(int[] arr, int startIndex, int endIndex) {
		int i, j, temp, std;
		// 循环至i=j
		if (startIndex > endIndex) {
			return;
		}
		// 确定基准数
		std = arr[startIndex];
		i = startIndex;
		j = endIndex;

		while (i < j) {
			// 从右边开始遍历，找到小于基准数的
			while (arr[j] >= std && i < j) {
				j--;
			}
			// 从左边开始遍历，找到大于基准数的
			while (arr[i] <= std && i < j) {
				i++;
			}
			// 交换
			if (i < j) {
				temp = arr[j];
				arr[j] = arr[i];
				arr[i] = temp;
			}
		}
		// 交换基准数与arr[i]
		arr[startIndex] = arr[i];
		arr[i] = std;
		// 左子序列递归
		quickSort(arr, startIndex, i - 1);
		// 右子序列递归
		quickSort(arr, i + 1, endIndex);
	}

	// 年龄排序
	public static int[] ageSort(int[] arr, int length) {
		int index = 0;
		int age;
		int oldestAge = 99;
		int[] timesofAge = new int[oldestAge + 1];
		// 从小到大统计每个年龄出现的次数
		for (int i = 0; i < length; i++) {
			age = arr[i];
			timesofAge[age + 1] += 1;
		}
		// 依次放到另一个数组中
		for (int i = 0; i <= oldestAge; i++) {
			for (int j = 0; j < timesofAge[i]; j++) {
				arr[index] = i;
				index++;
			}
		}
		System.out.println(Arrays.toString(arr));
		return arr;
	}

	// 旋转数组的最小值（二分思想）
	public static int findMin(int[] arr) {
		// 创建两个指针i，j位于左右两端
		int index1, index2, midIndex;
		index1 = 0;
		index2 = arr.length - 1;
		midIndex = index1;
		// 递归至两指针挨着，右边的指针所指的数为最小数
		while (index1 < index2 - 1) {
			midIndex = (index1 + index2) / 2;
			// 若数组为排序数组本身，直接输出第一个数字
			if (arr[index1] < arr[index2]) {
				break;
			}

			// 若三个数相等，只能调用顺寻查找
			if (arr[index1] == arr[index2] && arr[index1] == arr[midIndex]) {
				return orderFind(arr);
			}

			// 正常情况,，判断数组中间的数是处在左边数列、还是右边数列
			if (arr[midIndex] >= arr[0]) {
				index1 = midIndex;
			} else {
				index2 = midIndex;
			}
		}

		return arr[midIndex];
	}

	public static int orderFind(int[] arr) {
		int result = arr[0];
		for (int i = 0; i < arr.length - 1; i++) {
			if (arr[i] < result) {
				result = arr[i];
			}
		}
		return result;
	}
}