【leetcode】Find Minimum in Rotated Sorted Array JAVA实现

一、题目描述

Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

Find the minimum element.

You may assume no duplicate exists in the array.

 

二、分析

这题难度有，因为他默认的是数组中所有的元素是不同的。只有分为两种情况：

1、数组中所有的元素单调递增（0 1 2 4 5 6 7）

2、有个旋转点的（4 5 6 7 0 1 2），那就要根据中间值的位置判断是在前面的递增序列中还是后面的递增序列中

三、设计思路

1、 设置两个指针，初始状态第一个指针指向前面子数组的第一个元素，第二个指针指向后面子数组的最后一个元素；

2、 找到两个指针的中间元素；

3、若其大于等于第一个指针指向的元素，则说明其在前面的子数组中，且显然最小元素在中间元素的右边，若其小于等于第二个指针指向的元素，则说明其在后面的子数组中，且显然最小元素在中间元素的左边。

 

package com.edu.leetcode;

public class FindMinimuminRotatedSortedArray {

	public int findMin(int[] num) {
		if(num.length==1){
			return num[0];
		}	
		int i=0;
		int j=num.length-1;
		int mid=0;
		if(num[i]<num[j]){                        //单调递增的情况
			return num[0];
		}
		else{												//有拐点的情况
			while(i+1!=j){
				mid=(i+j)/2;
				if(num[mid]>num[i]){			//说明mid的位置在前面的递增序列中
					i=mid;
				}
				if(num[mid]<num[j]){			//说明mid的位置在后面的递增序列中
					j=mid;
				}
			}
			return num[j];
		} 
    }
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FindMinimuminRotatedSortedArray f= new FindMinimuminRotatedSortedArray();
		int[] num={4,5,6};
		System.out.println(f.findMin(num));
	}
}

　　

三、难度提升--当允许有重复的元素时

分析：

第一种解法：暴力求解--遍历整个数组，得到最小值

第二种解法：对半查找--思路跟上面大致相同，但不同是的当i，mid和j位置三个元素都相等时，没办法在使用对半方法，只能遍历整个数组

#include<iostream>
#include<stdlib.h>
#include<stack>
using namespace std;

int min(int arry[],int len)//返回最小数的坐标
{
    if(arry==NULL||len<=0)
        return -1;

    int start=0;
    int end=len-1;
    while(start<end)
    {
        //如果首个元素小于最后一个元素，表明数组是排序的。
        if(arry[start]<arry[end])
            return start;

        //当start指针和end指针隔壁的时候，返回end指针就是最小元素的坐标
        if(end-start==1)
            return end;
        int mid=(start+end)/2;
        //如果arry[mid],arry[start]和arry[end]三个数相等，就只能使用顺序查找
        if(arry[mid]==arry[start]&&arry[mid]==arry[end])
        {
            int index=start;
            for(int i=start+1;i<=end;i++)
            {
                if(arry[i]<arry[index])
                    index=i;
            }
            return index;
        }

        //如果中间元素小于末尾元素，那么表明中间元素在后半段数组中，修改end指针
        if(arry[mid]<arry[end])
        {
            end=mid;
        }
        //如果中间元素大于首元素，那么表明中间元素在前半段数组中，修改start指针
        else if(arry[mid]>arry[start])
        {
            start=mid;
        }
    }
    return -1;
}

int minNum(int arry[],int len)//返回最小数的值
{
    if(arry==NULL||len<=0)
        throw exception("非法输入");

    int start=0;
    int end=len-1;
    while(arry[start]>=arry[end])
    {
        if(end-start==1)//如果start和end相差1则返回arry[end]
            return arry[end];

        int mid=(start+end)/2;
        //如果arry[mid],arry[start]和arry[end]三个数相等，就只能使用顺序查找
        if(arry[mid]==arry[start]&&arry[mid]==arry[end])
        {
            int result=arry[start];
            for(int i=start+1;i<=end;i++)
            {
                if(arry[i]<result)
                    result=arry[i];
            }
            return result;
        }

        if(arry[mid]>=arry[start])//如果中间元素大于首元素，则移动首指针
        {
            start=mid;
        }
        else if(arry[mid]<=arry[end])
        {
            end=mid;
        }
    }
    return arry[start];//如果一开始arry[start]<arry[end]表明数组是排序数组，返回arry[start]
}

void main()
{
    int arry[]={1,0,1,1,1};
    int len=sizeof(arry)/sizeof(int);

    int index=min(arry,len);
    int minnum=minNum(arry,len);

    cout<<"最小数在数组中的位置："<<index<<endl;
    cout<<"最小数的值："<<minnum<<endl;

    system("pause");
}