זוך אין Rotated Sorted Array Leetcode לייזונג  


שוועריקייט לעוועל מיטל
אָפט געבעטן אין אַדאָובי אַליבאַבאַ אַמאַזאָן עפּל בלומבערג ביטעדאַנסע סיסקאָ עבייַ עקספּעדיאַ facebook גאָלדמאַן סאַקס גוגל דזשפּמאָרגאַן לינקעדין מייקראָסאָפֿט נוטאַניקס נווידיאַ אָראַקל פּייַפּאַל Paytm סאַלעספאָרסע סאַמסונג ServiceNow Tencent טעסלאַ טריפּאַדוויסאָר טוויטטש ובער וויזע וומוואַרע וואַלמאַרט לאַבס יאַהאָאָ יאַנדעקס זיללאָוו זולילי
אַלגערידאַמז מענגע ביינערי זוכן קאָדירונג אינטערוויו interviewprep LeetCode LeetCodeSolutions

באַטראַכטן אַ סאָרטירט מענגע אָבער איין אינדעקס איז פּיקט און די מענגע איז ראָוטייטיד אין דעם פונט. אַמאָל די מענגע איז ראָוטייטיד, איר דאַרפֿן צו געפֿינען אַ באַזונדער ציל עלעמענט און ווייַזן זיין אינדעקס. אין פאַל, די עלעמענט איז נישט פאָרשטעלן, צוריקקומען -1. דער פּראָבלעם איז בכלל ריפערד צו ווי זוכן אין ראָטאַטעד סאָרטעד עריי לעעטקאָדע סאַלושאַן. אַזוי אין די קשיא, מיר זענען צוגעשטעלט מיט אַ מענגע פון ​​עטלעכע ינטאַדזשער עלעמענטן וואָס זענען אויסגעשטעלט און ראָוטייטיד אין אַ זיכער אינדעקס וואָס איז ניט באַוווסט צו אונדז. צוזאַמען מיט די מענגע, מיר אויך באַקומען אַ ספּעציפיש עלעמענט וואָס מיר דאַרפֿן צו געפֿינען.

זוך אין Rotated Sorted Array Leetcode לייזונגשפּילקע

array: [4,5,6,7,0,1,2]
target: 4

דערקלערונג: זינט דער עלעמענט צו זוכן איז 4. דער עלעמענט איז געפֿונען אין אינדעקס 0, מיר ווייַזן די אינדעקס פון דער ציל.

array: [4,5,6,7,0,1,2]
target: 3
-1

דערקלערונג: זינט דער עלעמענט איז נישט פאָרשטעלן אין די מענגע, מיר צוריקקומען -1.

ברוט פאָרס צוגאַנג פֿאַר זוכן אין ראָטאַטעד סאָרטעד עריי  

די פּראָבלעם "זוכן אין ראָטאַטעד סאָרטעד עריי" פרעגט אונדז צו געפֿינען די אינדעקס פון דער ציל עלעמענט אין דער געגעבן ראָוטייטיד סאָרטעד מענגע. און מיר האָבן שוין דיסקאַסט וואָס אַ ראָוטייטיד סאָרטעד מענגע איז? דער סימפּלאַסט אופֿן אַז מען קען טראַכטן איז צו פּרובירן לינעאַר זוך. אין לינעאַר זוך, מיר פשוט פאָרן די געגעבן מענגע און טשעק אויב די קראַנט עלעמענט איז אונדזער ציל עלעמענט. אויב די קראַנט עלעמענט איז דער ציל עלעמענט מיר צוריקקומען די קראַנט אינדעקס אַנדערש מיר צוריקקומען -1. דער צוגאַנג איז זייער פּשוט, אָבער זינט עס ניצט נישט די פאַקט אַז די מענגע איז אויסגעשטעלט און ראָוטייטיד אין אַ איין אינדעקס. דער צוגאַנג האט לינעאַר צייט קאַמפּלעקסיטי.

זע אויך
N- טה טריבאָנאַט נומער לעעטקאָדע סאַלושאַן

קאָדעקס פֿאַר זוכן אין ראָטאַטעד סאָרטעד עריי לעעטקאָדע סאַלושאַן

C ++ קאָד

#include <bits/stdc++.h>
using namespace std;

int search(vector<int>& nums, int target) {
    int n = nums.size();
    for(int i=0;i<n;i++)
        if(nums[i] == target)
            return i;
    return -1;
}

int main(){
    vector<int> nums({4,5,6,7,0,1,2});
    cout<<search(nums, 4);
}

Java קאוד

import java.util.*;
import java.lang.*;
import java.io.*;

class Main {
    public static int search(int[] nums, int target) {
        int n = nums.length;
        for(int i=0;i<n;i++)
            if(nums[i] == target)
                return i;
        return -1;
    }
    
    public static void main(String[] args){
    	int nums[] = {4,5,6,7,0,1,2};
    	System.out.println(search(nums, 4));
    }
}

קאַמפּלעקסיטי אַנאַליסיס

צייט קאַמפּלעקסיטי

אָ (N), ווייַל אין די ערגסט פאַל, די ציל עלעמענט קען זיין פאָרשטעלן אין די סוף פון די מענגע. אזוי די צייט קאַמפּלעקסיטי איז לינעאַר.

ספעיס קאַמפּלעקסיטי

אָ (1)זינט מיר טאָן ניט האָבן קיין אינפֿאָרמאַציע וועגן יעדער עלעמענט ספּאַסיפיקלי און האָבן געוויינט אַ קעסיידערדיק נומער פון וועריאַבאַלז. אזוי די פּלאַץ קאַמפּלעקסיטי איז קעסיידערדיק.

אָפּטימיזעד צוגאַנג פֿאַר זוכן אין ראָטאַטעד סאָרטעד עריי  

די דערמאנט צוגאַנג האט נישט נוצן די פאַקט אַז די מענגע איז געווען אַ ראָוטייטיד סאָרטירט מענגע. אַזוי, אין דעם צוגאַנג, מיר פּרובירן צו נוצן דעם פאַקט צו רעדוצירן די צייט קאַמפּלעקסיטי. באַטראַכטן, אויב מיר האָבן אַ סאָרטעד מענגע, מיר וואָלט האָבן נאָר געוויינט ביינערי זוכן אָבער אין פאַל דאָס איז אַ ביסל טריקי. דאָ מיר אויך דאַרפֿן צו נוצן ביינערי זוכן. אָבער אויב מיר נוצן ביינערי זוכן, ווי טאָן מיר וויסן וואָס טייל פון די מענגע צו קלייַבן אַמאָל מיר זענען אין די מיטל עלעמענט פון די מענגע? ווייַל מיר קענען נישט פשוט נאָכגיין די אָריגינעל ביינערי זוכן אַלגערידאַם ווייַל דאָס איז אַ ראָוטייטיד סאָרטירט מענגע. אַזוי, עס איז אַ קליין מאָדיפיקאַטיאָן איבער דער נאָרמאַל ביינערי זוכן.

אַזוי, טיפּיקלי ביי ביינערי זוכן, מיר קאָנטראָלירן אויב די קראַנט עלעמענט (עלעמענט אין מיטן אינדעקס) איז די זעלבע ווי דער ציל, און מיר צוריקקומען די אינדעקס. דער שריט בלייבט זעלביקער דאָ. אַחוץ דעם, אויב זיי זענען נישט די זעלבע, מיר קאָנטראָלירן אויב די דרייפּונקט ליגט צו די רעכט [פון די קראַנט עלעמענט אָדער צו די לינקס. אויב עס ליגט צו די רעכט, מיר קאָנטראָלירן אויב די ציל ליגט אין ניט-ראָוטייטיד סובאַרראַי, אויב דאָס איז דערהייַנטיקן די הויך אַנדערש מיר דערהייַנטיקן די נידעריק. סימילאַרלי, אויב די דרייפּונקט ליגט צו די לינקס, מיר קאָנטראָלירן ווידער אויב די ציל ליגט אין די ניט-ראָוטייטיד סובאַרראַי, מיר דערהייַנטיקן די נידעריק, אַנדערש מיר דערהייַנטיקן די הויך. אין די סוף, אויב מיר קומען אויס פון די שלייף, מיר זענען זיכער אַז דער ציל איז נישט פאָרשטעלן אין די געגעבן מענגע.

זע אויך
Sqrt (x) Leetcode לייזונג

אָפּטימיזעד קאָד פֿאַר זוכן אין ראָטאַטעד סאָרטעד עריי לעעטקאָדע סאַלושאַן

C ++ קאָד

#include <bits/stdc++.h>
using namespace std;

int search(vector<int>& nums, int target) {
    int n = nums.size();
    int low = 0, high = n-1;
    while(low<=high){
        int mid = (low+high)/2;
        // check if the current element is target
        if(nums[mid] == target)
            return mid;
        // if the starting index of the search space has smaller element than current element
        else if(nums[low]<=nums[mid]){
            // if target lies in non-rotated search space (or subarray)
            if(target >= nums[low] && target < nums[mid])
                high = mid - 1;
            else
                low = mid + 1;
        } else {
            // if target lies in non-rotated subarray
            if(target>nums[mid] && target<=nums[high])
                low = mid + 1;
            else
                high = mid - 1;
        }
    }
    // if you couldn't find the target element until now then it does not exists
    return -1;
}
int main(){
    vector<int> nums({4,5,6,7,0,1,2});
    cout<<search(nums, 4);
}

Java קאָד

import java.util.*;
import java.lang.*;
import java.io.*;

class Main {
    public static int search(int[] nums, int target) {
        int n = nums.length;
        int low = 0, high = n-1;
        while(low<=high){
            int mid = (low+high)/2;
            // check if the current element is target
            if(nums[mid] == target)
                return mid;
            // if the starting index of the search space has smaller element than current element
            else if(nums[low]<=nums[mid]){
                // if target lies in non-rotated search space (or subarray)
                if(target >= nums[low] && target < nums[mid])
                    high = mid - 1;
                else
                    low = mid + 1;
            } else {
                // if target lies in non-rotated subarray
                if(target>nums[mid] && target<=nums[high])
                    low = mid + 1;
                else
                    high = mid - 1;
            }
        }
        // if you couldn't find the target element until now then it does not exists
        return -1;
    }
    
    public static void main(String[] args){
    	int nums[] = {4,5,6,7,0,1,2};
    	System.out.println(search(nums, 4));
    }
}

קאַמפּלעקסיטי אַנאַליסיס

צייט קאַמפּלעקסיטי

אָ (קלאָץ N), זינט מיר האָבן געוויינט ביינערי זוכן צו געפֿינען די ציל עלעמענט. די צייט קאַמפּלעקסיטי איז לאָגאַריטמיק.

זע אויך
געפֿינען מינימום חילוק צווישן צוויי עלעמענטן

ספעיס קאַמפּלעקסיטי

אָ (1), זינט מיר סטאָרד בלויז עטלעכע קעסיידערדיק נומער פון עלעמענטן, די פּלאַץ קאַמפּלעקסיטי איז קעסיידערדיק.