zoukankan      html  css  js  c++  java
  • 33.search in rotated sorted array leetcode 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).

    You are given a target value to search. If found in the array return its index, otherwise return -1.

    You may assume no duplicate exists in the array.

    博主表示看题看了很久之后,找规律喽~ debug N久之后总算得到的正确的结果把自己都绕晕了~~

    这是一道binary search的变体,总有一边是有序的~~

    package leetcode2;
    
    public class Search_in_Rotated {
       public static int search(int[] A, int target) {
            int location;      
            location=binarysearch(A,target,0,A.length-1);
            return location;
            
        }
       public static int binarysearch(int[] A, int target,int left,int right) {
          int mid=(int)(left+right)/2;
          if(A[mid]==target){
              return mid;
          }
          if(left<=right){
          if(target>A[mid]){
              if(A[mid]<A[right] && target<=A[right]){
                  return binarysearch(A,target,mid+1,right); // 一定注意!!(mid+1,right)
              }else if(A[mid]>A[left]){
                  return binarysearch(A,target,mid+1,right);  // (mid+1,right)
              }else{
                  return binarysearch(A,target,left,mid-1);  //(left,mid-1)!!!
              }
          }
          if(target<A[mid]){
              if(A[mid]>A[left] && target>=A[left]){
                  return binarysearch(A,target,left,mid-1);
              }else if(A[mid]<A[right]){
                  return binarysearch(A,target,left,mid-1);
              }else{
                  return binarysearch(A,target,mid+1,right);
              } 
          }
          }
          return -1;
       }
        public static void main(String[] args) {
            // TODO Auto-generated method stub
          int[] a={2,3,4,5,7,0,1};
          System.out.println(search(a, 4));
        }
    
    }

    然后看了看别人的代码,博主表示自己真是too young too naive!!其实自己是在练习迭代是吧orz!QAQ

    int rotated_binary_search(int A[], int N, int key) {
      int L = 0;
      int R = N - 1;
     
      while (L <= R) {
        // Avoid overflow, same as M=(L+R)/2
        int M = L + ((R - L) / 2);
        if (A[M] == key) return M;
     
        // the bottom half is sorted
        if (A[L] <= A[M]) {
          if (A[L] <= key && key < A[M])
            R = M - 1;
          else
            L = M + 1;
        }
        // the upper half is sorted
        else {
          if (A[M] < key && key <= A[R])
            L = M + 1;
          else 
            R = M - 1;
        }
      }
      return -1;
    }
  • 相关阅读:
    HDU 5213 分块 容斥
    HDU 2298 三分
    HDU 5144 三分
    HDU 5145 分块 莫队
    HDU 3938 并查集
    HDU 3926 并查集 图同构简单判断 STL
    POJ 2431 优先队列
    HDU 1811 拓扑排序 并查集
    HDU 2685 GCD推导
    HDU 4496 并查集 逆向思维
  • 原文地址:https://www.cnblogs.com/joannacode/p/4390202.html
Copyright © 2011-2022 走看看