วิธีที่มีประสิทธิภาพในการค้นหาองค์ประกอบ

เมื่อเร็ว ๆ นี้ฉันได้ให้สัมภาษณ์ซึ่งพวกเขาถามคำถาม " ค้นหา "
คำถามคือ:

ถือว่ามีอาร์เรย์ของ (บวก) จำนวนเต็มซึ่งแต่ละองค์ประกอบเป็นอย่างใดอย่างหนึ่ง+1หรือ-1เมื่อเทียบกับองค์ประกอบที่อยู่ใกล้เคียง

ตัวอย่าง:

array = [4,5,6,5,4,3,2,3,4,5,6,7,8];

ตอนนี้ค้นหา7และส่งคืนตำแหน่ง

ฉันให้คำตอบนี้:

จัดเก็บค่าในอาร์เรย์ชั่วคราวเรียงลำดับแล้วใช้การค้นหาแบบไบนารี

หากพบองค์ประกอบให้คืนตำแหน่งในอาร์เรย์ชั่วคราว
(หากตัวเลขเกิดขึ้นสองครั้งให้คืนค่าที่เกิดขึ้นครั้งแรก)

แต่ดูเหมือนพวกเขาจะไม่พอใจกับคำตอบนี้

คำตอบที่ถูกต้องคืออะไร?

คุณสามารถทำการค้นหาเชิงเส้นที่มีขั้นตอนที่มักจะสูงกว่า 1. สังเกตที่สำคัญคือว่าถ้าเช่นarray[i] == 4และ 7 ยังไม่ได้ปรากฏตัวขึ้นแล้วผู้สมัครต่อไปสำหรับ 7 i+3เป็นที่ดัชนี ใช้ while loop ซึ่งจะส่งตรงไปยังผู้สมัครคนถัดไป

นี่คือการนำไปใช้โดยทั่วไปเล็กน้อย พบการเกิดขึ้นครั้งแรกkในอาร์เรย์ (ขึ้นอยู่กับข้อ จำกัด + = 1) หรือ-1หากไม่เกิดขึ้น:

#include <stdio.h>
#include <stdlib.h>

int first_occurence(int k, int array[], int n);

int main(void){
    int a[] = {4,3,2,3,2,3,4,5,4,5,6,7,8,7,8};
    printf("7 first occurs at index %d\n",first_occurence(7,a,15));
    printf("but 9 first \"occurs\" at index %d\n",first_occurence(9,a,15));
    return 0;
}

int first_occurence(int k, int array[], int n){
    int i = 0;
    while(i < n){
        if(array[i] == k) return i;
        i += abs(k-array[i]);
    }
    return -1;
}

เอาต์พุต:

7 first occurs at index 11
but 9 first "occurs" at index -1

แนวทางของคุณซับซ้อนเกินไป คุณไม่จำเป็นต้องตรวจสอบทุกองค์ประกอบของอาร์เรย์ ค่าแรกคือ4เพื่อให้7เป็นอย่างน้อย 7-4องค์ประกอบออกไปและคุณสามารถข้ามเหล่านั้น

#include <stdio.h>
#include <stdlib.h>

int main (void)
{
    int array[] = {4,5,6,5,4,3,2,3,4,5,6,7,8};
    int len = sizeof array / sizeof array[0];
    int i = 0;
    int steps = 0;
    while (i < len && array[i] != 7) {
        i += abs(7 - array[i]);
        steps++;
    }

    printf("Steps %d, index %d\n", steps, i);
    return 0;
}

ผลลัพธ์ของโปรแกรม:

Steps 4, index 11

แก้ไข: ปรับปรุงหลังจากความคิดเห็นจาก @Raphael Miedl และ @Martin Zabel

รูปแบบของการค้นหาเชิงเส้นทั่วไปอาจเป็นวิธีที่ดี array[i] = 2ให้เราเลือกพูดองค์ประกอบ ตอนนี้array[i + 1]จะเป็น 1 หรือ 3 (คี่)array[i + 2]จะเป็น (จำนวนเต็มบวกเท่านั้น) 2 หรือ 4 (เลขคู่)

ในการดำเนินการต่อเช่นนี้รูปแบบสามารถสังเกตได้ - array[i + 2*n]จะมีตัวเลขคู่และดัชนีเหล่านี้ทั้งหมดจึงไม่สามารถมองข้ามได้

นอกจากนี้เรายังสามารถดูได้

array[i + 3] = 1 or 3 or 5
array[i + 5] = 1 or 3 or 5 or 7

ดังนั้นi + 5ควรตรวจสอบดัชนีถัดไปและสามารถใช้ while loop เพื่อกำหนดดัชนีถัดไปที่จะตรวจสอบขึ้นอยู่กับค่าที่พบในดัชนีi + 5ควรจะตรวจสอบต่อไปและในขณะที่วงสามารถนำมาใช้ในการกำหนดดัชนีต่อไปเพื่อตรวจสอบขึ้นอยู่กับค่าที่พบในดัชนี

ขณะนี้มีความซับซ้อน O(n) (เวลาเชิงเส้นในแง่ของความซับซ้อนของ asymptotic) แต่จะดีกว่าการค้นหาเชิงเส้นปกติในแง่ปฏิบัติเนื่องจากไม่ได้เข้าชมดัชนีทั้งหมด

เห็นได้ชัดว่าทั้งหมดนี้จะกลับกันถ้าarray[i](จุดเริ่มต้นของเรา) เป็นเลขคี่

แนวทางที่ John Coleman นำเสนอคือสิ่งที่ผู้สัมภาษณ์คาดหวังในความเป็นไปได้ทั้งหมด
หากคุณมีความยินดีที่จะไปไม่น้อยที่มีความซับซ้อนมากขึ้นคุณสามารถเพิ่มความยาวเฮี๊ยบคาดว่า:
โทรค่าเป้าหมายk เริ่มต้นด้วยองค์ประกอบแรกของค่าโวลต์ที่ตำแหน่งPและเรียกแตกต่าง KV DVกับค่าสัมบูรณ์AV การค้นหาเชิงลบความเร็วได้มองที่องค์ประกอบสุดท้ายเป็นค่าอื่น ๆยูในตำแหน่งo: ถ้า dv × du เป็นค่าลบจะมีค่า k อยู่ (หากยอมรับการเกิด k ใด ๆ คุณอาจ จำกัด ช่วงดัชนีให้แคบลงตามวิธีการค้นหาไบนารี) ถ้า av + au มากกว่าความยาวของอาร์เรย์จะไม่มี k (ถ้า DV ×ดู่เป็นศูนย์วี u หรือเท่ากับ k.)
ดัชนีถนัดความถูกต้อง: การวัดนี้ ( "ถัดไป") ตำแหน่งที่ลำดับอาจจะกลับไปที่วีกับ k o = p + 2*avที่อยู่ตรงกลาง:
ถ้า dv × du เป็นลบให้หา k (เรียกซ้ำ?) จาก p + av ถึง o-au;
ถ้าเป็นศูนย์คุณจะเท่ากับ k ที่ o
หาก du เท่ากับ dv และค่าที่อยู่ตรงกลางไม่ใช่ k หรือ au เกิน av
หรือคุณไม่พบ k จาก p + av ถึง o-au
ให้ปล่อยp=o; dv=du; av=au;และตรวจสอบต่อไป
(สำหรับการย้อนกลับไปยังข้อความ '60ies เต็มรูปแบบให้ดูด้วย Courier "ความคิดที่ 2 ครั้งที่ 1" ของฉันคือการใช้o = p + 2*av - 1ซึ่งไม่รวมdu เท่ากับ dv .)

ขั้นตอนที่ 1

เริ่มต้นด้วยองค์ประกอบแรกและตรวจสอบว่าเป็น 7 หรือไม่สมมติว่าcเป็นดัชนีของตำแหน่งปัจจุบัน c = 0ดังนั้นในขั้นต้น

ขั้นตอนที่ 2

ถ้าเป็น 7 คุณจะพบดัชนี มันc. หากคุณมาถึงจุดสิ้นสุดของอาร์เรย์แล้วให้แยกออก

ขั้นตอนที่ 3

หากไม่เป็นเช่นนั้น 7 จะต้องอยู่|array[c]-7|ห่างออกไปอย่างน้อยที่สุดเนื่องจากคุณสามารถเพิ่มหน่วยต่อดัชนีได้เท่านั้น ดังนั้นเพิ่ม|array[c]-7|ในดัชนีปัจจุบันของคุณ c และไปที่ขั้นตอนที่ 2 อีกครั้งเพื่อตรวจสอบ

ในกรณีที่เลวร้ายที่สุดเมื่อมีตัวเลือก 1 และ -1 ความซับซ้อนของเวลาอาจถึง O (n) แต่กรณีโดยเฉลี่ยจะถูกส่งอย่างรวดเร็ว

ที่นี่ฉันกำลังให้การใช้งานใน java ...

public static void main(String[] args) 
{       
    int arr[]={4,5,6,5,4,3,2,3,4,5,6,7,8};
    int pos=searchArray(arr,7);

    if(pos==-1)
        System.out.println("not found");
    else
        System.out.println("position="+pos);            
}

public static int searchArray(int[] array,int value)
{
    int i=0;
    int strtValue=0;
    int pos=-1;

    while(i<array.length)
    {
        strtValue=array[i];

        if(strtValue<value)
        {
            i+=value-strtValue;
        }
        else if (strtValue==value)
        {
            pos=i;
            break;
        }
        else
        {
            i=i+(strtValue-value);
        }       
    }

    return pos;
}

นี่คือวิธีแก้ปัญหาแบบแบ่งและพิชิต ด้วยค่าใช้จ่ายในการทำบัญชีที่มากขึ้น (มาก) เราสามารถข้ามองค์ประกอบต่างๆได้มากขึ้น แทนที่จะสแกนจากซ้ายไปขวาให้ทดสอบตรงกลางแล้วข้ามไปทั้งสองทิศทาง

#include <stdio.h>                                                               
#include <math.h>                                                                

int could_contain(int k, int left, int right, int width);                        
int find(int k, int array[], int lower, int upper);   

int main(void){                                                                  
    int a[] = {4,3,2,3,2,3,4,5,4,5,6,7,8,7,8};                                   
    printf("7 first occurs at index %d\n",find(7,a,0,14));                       
    printf("but 9 first \"occurs\" at index %d\n",find(9,a,0,14));               
    return 0;                                                                    
}                                                                                

int could_contain(int k, int left, int right, int width){                        
  return (width >= 0) &&                                                         
         (left <= k && k <= right) ||                                            
         (right <= k && k <= left) ||                                            
         (abs(k - left) + abs(k - right) < width);                               
}                                                                                

int find(int k, int array[], int lower, int upper){                              
  //printf("%d\t%d\n", lower, upper);                                            

  if( !could_contain(k, array[lower], array[upper], upper - lower )) return -1;  

  int mid = (upper + lower) / 2;                                                 

  if(array[mid] == k) return mid;                                                

  lower = find(k, array, lower + abs(k - array[lower]), mid - abs(k - array[mid]));
  if(lower >= 0 ) return lower;                                                    

  upper = find(k, array, mid + abs(k - array[mid]), upper - abs(k - array[upper]));
  if(upper >= 0 ) return upper;                                                  

  return -1;                                                                     

}

const findMeAnElementsFunkyArray = (arr, ele, i) => {
  const elementAtCurrentIndex = arr[i];

  const differenceBetweenEleAndEleAtIndex = Math.abs(
    ele - elementAtCurrentIndex
  );

  const hop = i + differenceBetweenEleAndEleAtIndex;

  if (i >= arr.length) {
    return;
  }
  if (arr[i] === ele) {
    return i;
  }

  const result = findMeAnElementsFunkyArray(arr, ele, hop);

  return result;
};

const array = [4,5,6,5,4,3,2,3,4,5,6,7,8];

const answer = findMeAnElementsFunkyArray(array, 7, 0);

console.log(answer);

ต้องการรวมวิธีแก้ปัญหาแบบวนซ้ำสำหรับปัญหา สนุก