การค้นหารายการที่ซ้ำกันในเวลา O (n) และช่องว่าง O (1)

อินพุต: กำหนดอาร์เรย์ขององค์ประกอบ n ซึ่งมีองค์ประกอบตั้งแต่ 0 ถึง n-1 โดยตัวเลขเหล่านี้จะปรากฏกี่ครั้งก็ได้

เป้าหมาย: เพื่อค้นหาตัวเลขที่เกิดซ้ำเหล่านี้ใน O (n) และใช้พื้นที่หน่วยความจำคงที่เท่านั้น

ตัวอย่างเช่นให้ n เป็น 7 และอาร์เรย์เป็น {1, 2, 3, 1, 3, 0, 6} คำตอบควรเป็น 1 & 3 ฉันตรวจสอบคำถามที่คล้ายกันที่นี่ แต่คำตอบใช้โครงสร้างข้อมูลบางอย่างเช่น HashSetฯลฯ

อัลกอริทึมที่มีประสิทธิภาพเหมือนกันหรือไม่?

นี่คือสิ่งที่ฉันคิดขึ้นมาซึ่งไม่ต้องการบิตเครื่องหมายเพิ่มเติม:

for i := 0 to n - 1
    while A[A[i]] != A[i] 
        swap(A[i], A[A[i]])
    end while
end for

for i := 0 to n - 1
    if A[i] != i then 
        print A[i]
    end if
end for

วงแรก permutes อาร์เรย์เพื่อที่ว่าถ้าองค์ประกอบเป็นปัจจุบันอย่างน้อยหนึ่งครั้งจากนั้นหนึ่งของรายการเหล่านั้นจะอยู่ที่ตำแหน่งxA[x]

สังเกตว่ามันอาจจะไม่ดู O (n) ในตอนแรกบลัชออน แต่มันก็เป็น - แม้ว่ามันจะมีการวนซ้ำที่ซ้อนกัน แต่ก็ยังคงทำงานได้O(N)ทันเวลา การแลกเปลี่ยนจะเกิดขึ้นก็ต่อเมื่อมีสิ่งiนั้นA[i] != iและการแลกเปลี่ยนแต่ละครั้งจะตั้งค่าองค์ประกอบอย่างน้อยหนึ่งอย่างA[i] == iซึ่งไม่เคยเป็นจริงมาก่อน ซึ่งหมายความว่าจำนวนรวมของสัญญาแลกเปลี่ยน (และจำนวนรวมของการประหารชีวิตของwhileร่างกายห่วง) N-1เป็นอย่างมาก

ลูปที่สองพิมพ์ค่าxที่A[x]ไม่เท่ากันxเนื่องจากลูปแรกรับประกันว่าหากxมีอยู่อย่างน้อยหนึ่งครั้งในอาร์เรย์หนึ่งในอินสแตนซ์เหล่านั้นจะอยู่ที่A[x]นั่นหมายความว่าจะพิมพ์ค่าxที่ไม่มีอยู่ใน อาร์เรย์

(ลิงค์ Ideone เพื่อให้คุณสามารถเล่นได้)

คำตอบที่ยอดเยี่ยมของ caf จะพิมพ์ตัวเลขแต่ละตัวที่ปรากฏ k ครั้งในอาร์เรย์ k-1 ครั้ง นั่นเป็นพฤติกรรมที่มีประโยชน์ แต่คำถามนั้นเรียกร้องให้พิมพ์ซ้ำแต่ละรายการเพียงครั้งเดียวและเขากล่าวถึงความเป็นไปได้ที่จะทำสิ่งนี้โดยไม่ต้อง จำกัด เวลาเชิงเส้น / ขอบเขตของพื้นที่คงที่ ซึ่งสามารถทำได้โดยแทนที่ลูปที่สองของเขาด้วยรหัสเทียมต่อไปนี้:

for (i = 0; i < N; ++i) {
    if (A[i] != i && A[A[i]] == A[i]) {
        print A[i];
        A[A[i]] = i;
    }
}

สิ่งนี้ใช้ประโยชน์จากคุณสมบัติที่หลังจากลูปแรกทำงานหากค่าใด ๆmปรากฏมากกว่าหนึ่งครั้งการปรากฏอย่างใดอย่างหนึ่งเหล่านั้นจะได้รับการรับรองว่าอยู่ในตำแหน่งที่ถูกต้องกล่าวคือA[m]ปรากฏมากกว่าหนึ่งครั้งจากนั้นหนึ่งของสิ่งที่ปรากฏเหล่านั้นรับประกันได้ว่าจะอยู่ในตำแหน่งที่ถูกต้องคือหากเราระมัดระวังเราสามารถใช้ตำแหน่ง "บ้าน" นั้นเพื่อจัดเก็บข้อมูลว่ามีการพิมพ์ซ้ำหรือยัง

ในเวอร์ชันของ caf ขณะที่เราอ่านอาร์เรย์A[i] != iโดยนัยว่าA[i]เป็นข้อมูลที่ซ้ำกัน ในเวอร์ชันของฉันฉันใช้ค่าคงที่ที่แตกต่างกันเล็กน้อยนั่นA[i] != i && A[A[i]] == A[i]หมายความว่าA[i]ซ้ำกันที่เราไม่เคยเห็นมาก่อนว่าเราไม่ได้เห็นมาก่อน(หากคุณวางส่วน "ที่เราไม่เคยเห็นมาก่อน" ส่วนที่เหลือสามารถเห็นได้โดยนัยโดยความจริงของค่าคงที่ของคาเฟ่และการรับประกันว่ารายการที่ซ้ำกันทั้งหมดมีสำเนาบางส่วนในตำแหน่งบ้าน) คุณสมบัตินี้ถืออยู่ที่ จุดเริ่มต้น (หลังจากจบการวนรอบที่ 1 ของ Caf) และฉันแสดงให้เห็นด้านล่างว่ามันคงอยู่หลังจากแต่ละขั้นตอน

ในขณะที่เราดำเนินการตามอาร์เรย์ความสำเร็จในA[i] != iส่วนของการทดสอบแสดงให้เห็นว่าA[i] อาจซ้ำซ้อนที่ไม่เคยมีมาก่อน หากเราไม่เคยเห็นมาก่อนเราคาดว่าA[i]ตำแหน่งบ้านจะชี้ไปที่ตัวมันเองนั่นคือสิ่งที่ทดสอบในช่วงครึ่งหลังของifสภาพ หากเป็นเช่นนั้นเราจะพิมพ์และแก้ไขตำแหน่งบ้านให้ชี้กลับไปที่รายการที่พบครั้งแรกนี้โดยสร้าง "วงจร" 2 ขั้นตอน

จะเห็นว่าการดำเนินการนี้ไม่เปลี่ยนแปลงคงที่เราคิดว่าm = A[i]สำหรับตำแหน่งโดยเฉพาะอย่างยิ่งความพึงพอใจi A[i] != i && A[A[i]] == A[i]เห็นได้ชัดว่าการเปลี่ยนแปลงที่เราทำ ( A[A[i]] = i) จะทำงานเพื่อป้องกันไม่ให้เกิดเหตุการณ์อื่น ๆ ที่ไม่ใช่บ้านmจากการส่งออกเป็นรายการซ้ำโดยทำให้เงื่อนไขครึ่งหลังifล้มเหลว แต่จะได้ผลเมื่อiมาถึงที่ตั้งบ้านmหรือไม่ ใช่มันจะเป็นเพราะตอนนี้แม้ว่าที่ใหม่นี้iเราพบว่าครึ่งแรกของifเงื่อนไขนั้นA[i] != iเป็นจริงครึ่งหลังจะทดสอบว่าสถานที่ที่ชี้ไปนั้นเป็นตำแหน่งบ้านหรือไม่และพบว่าไม่ใช่ ในสถานการณ์นี้เราไม่รู้อีกต่อไปว่าเป็นค่าที่ซ้ำกันmหรือไม่A[m]แต่เรารู้ว่าไม่ว่าจะด้วยวิธีใดได้รับการรายงานเนื่องจาก 2 รอบนี้รับประกันว่าจะไม่ปรากฏในผลลัพธ์ของการวนรอบที่ 1 ของ caf (โปรดทราบว่าถ้าอย่างm != A[m]นั้นอย่างใดอย่างหนึ่งmและA[m]เกิดขึ้นมากกว่าหนึ่งครั้งและอีกรายการหนึ่งจะไม่เกิดขึ้นเลย)

นี่คือรหัสเทียม

for i <- 0 to n-1:
   if (A[abs(A[i])]) >= 0 :
       (A[abs(A[i])]) = -(A[abs(A[i])])
   else
      print i
end for

โค้ดตัวอย่างใน C ++

สำหรับ N ที่ค่อนข้างเล็กเราสามารถใช้การดำเนินการ div / mod

n.times do |i|
  e = a[i]%n
  a[e] += n
end

n.times do |i| 
  count = a[i]/n
  puts i if count > 1
end

ไม่ใช่ C / C ++ แต่อย่างไรก็ตาม

http://ideone.com/GRZPI

ไม่สวยจริงๆ แต่อย่างน้อยก็ดูคุณสมบัติ O (N) และ O (1) ได้ง่าย โดยทั่วไปเราจะสแกนอาร์เรย์และสำหรับแต่ละหมายเลขเราจะดูว่าตำแหน่งที่เกี่ยวข้องถูกตั้งค่าสถานะไว้แล้ว - เห็นครั้งเดียว (N) หรือเห็นแล้ว - หลายครั้ง (N + 1) หากถูกตั้งค่าสถานะแล้วเห็นครั้งเดียวเราจะพิมพ์และตั้งค่าสถานะที่เห็นแล้วหลายครั้ง หากไม่ถูกตั้งค่าสถานะเราจะตั้งค่าสถานะที่เห็นแล้วครั้งเดียวและเราย้ายค่าดั้งเดิมของดัชนีที่เกี่ยวข้องไปยังตำแหน่งปัจจุบัน (การตั้งค่าสถานะเป็นการดำเนินการทำลายล้าง)

for (i=0; i<a.length; i++) {
  value = a[i];
  if (value >= N)
    continue;
  if (a[value] == N)  {
    a[value] = N+1; 
    print value;
  } else if (a[value] < N) {
    if (value > i)
      a[i--] = a[value];
    a[value] = N;
  }
}

หรือยังดีกว่า (เร็วกว่าแม้จะวนซ้ำสองครั้ง):

for (i=0; i<a.length; i++) {
  value = a[i];
  while (value < N) {
    if (a[value] == N)  {
      a[value] = N+1; 
      print value;
      value = N;
    } else if (a[value] < N) {
      newvalue = value > i ? a[value] : N;
      a[value] = N;
      value = newvalue;
    }
  }
}

วิธีแก้ปัญหาหนึ่งใน C คือ:

#include <stdio.h>

int finddup(int *arr,int len)
{
    int i;
    printf("Duplicate Elements ::");
    for(i = 0; i < len; i++)
    {
        if(arr[abs(arr[i])] > 0)
          arr[abs(arr[i])] = -arr[abs(arr[i])];
        else if(arr[abs(arr[i])] == 0)
        {
             arr[abs(arr[i])] = - len ;
        }
        else
          printf("%d ", abs(arr[i]));
    }

}
int main()
{   
    int arr1[]={0,1,1,2,2,0,2,0,0,5};
    finddup(arr1,sizeof(arr1)/sizeof(arr1[0]));
    return 0;
}

เป็นเวลา O (n) และความซับซ้อนของพื้นที่ O (1)

สมมติว่าเรานำเสนออาร์เรย์นี้เป็นโครงสร้างข้อมูลกราฟทิศทางเดียว - แต่ละตัวเลขคือจุดยอดและดัชนีในอาร์เรย์จะชี้ไปยังจุดยอดอื่นที่ก่อตัวเป็นขอบของกราฟ

เพื่อความง่ายยิ่งขึ้นเรามีดัชนี 0 ถึง n-1 และช่วงของตัวเลขตั้งแต่ 0..n-1 เช่น

   0  1  2  3  4 
 a[3, 2, 4, 3, 1]

0 (3) -> 3 (3) คือวัฏจักร

คำตอบ: เพียงสำรวจอาร์เรย์โดยอาศัยดัชนี ถ้า a [x] = a [y] มันเป็นวัฏจักรและซ้ำกัน ข้ามไปที่ดัชนีถัดไปและดำเนินการต่ออีกครั้งไปเรื่อย ๆ จนกระทั่งสิ้นสุดอาร์เรย์ ความซับซ้อน: เวลา O (n) และช่องว่าง O (1)

รหัสหลามเล็ก ๆ เพื่อสาธิตวิธีการของ caf ด้านบน:

a = [3, 1, 1, 0, 4, 4, 6] 
n = len(a)
for i in range(0,n):
    if a[ a[i] ] != a[i]: a[a[i]], a[i] = a[i], a[a[i]]
for i in range(0,n):
    if a[i] != i: print( a[i] )

อัลกอริทึมสามารถมองเห็นได้ง่ายในฟังก์ชัน C ต่อไปนี้ การดึงข้อมูลอาร์เรย์เดิมแม้ว่าจะไม่จำเป็นต้องจะเป็นไปได้การแต่ละรายการโมดูโลn

void print_repeats(unsigned a[], unsigned n)
{
    unsigned i, _2n = 2*n;
    for(i = 0; i < n; ++i) if(a[a[i] % n] < _2n) a[a[i] % n] += n;
    for(i = 0; i < n; ++i) if(a[i] >= _2n) printf("%u ", i);
    putchar('\n');
}

Ideone Link สำหรับการทดสอบ

static void findrepeat()
{
    int[] arr = new int[7] {0,2,1,0,0,4,4};

    for (int i = 0; i < arr.Length; i++)
    {
        if (i != arr[i])
        {
            if (arr[i] == arr[arr[i]])
            {
                Console.WriteLine(arr[i] + "!!!");
            }

            int t = arr[i];
            arr[i] = arr[arr[i]];
            arr[t] = t;
        }
    }

    for (int j = 0; j < arr.Length; j++)
    {
        Console.Write(arr[j] + " ");
    }
    Console.WriteLine();

    for (int j = 0; j < arr.Length; j++)
    {
        if (j == arr[j])
        {
            arr[j] = 1;
        }
        else
        {
            arr[arr[j]]++;
            arr[j] = 0;
        }
    }

    for (int j = 0; j < arr.Length; j++)
    {
        Console.Write(arr[j] + " ");
    }
    Console.WriteLine();
}

ฉันได้สร้างแอปสนามเด็กเล่นตัวอย่างหนึ่งแอปอย่างรวดเร็วสำหรับการค้นหารายการที่ซ้ำกันในความซับซ้อนของเวลา 0 (n) และพื้นที่เพิ่มเติมคงที่ โปรดตรวจสอบ url ค้นหารายการที่ซ้ำกัน

โซลูชันIMP Above ทำงานเมื่ออาร์เรย์มีองค์ประกอบตั้งแต่ 0 ถึง n-1 โดยตัวเลขเหล่านี้จะปรากฏขึ้นกี่ครั้งก็ได้

private static void printRepeating(int arr[], int size) {
        int i = 0;
        int j = 1;
        while (i < (size - 1)) {
            if (arr[i] == arr[j]) {
                System.out.println(arr[i] + " repeated at index " + j);
                j = size;
            }
            j++;
            if (j >= (size - 1)) {
                i++;
                j = i + 1;
            }
        }

    }

หากอาร์เรย์ไม่ใหญ่เกินไปวิธีนี้จะง่ายกว่าก็จะสร้างอาร์เรย์อื่นที่มีขนาดเท่ากันสำหรับการทำเครื่องหมาย

1 สร้างบิตแมป / อาร์เรย์ที่มีขนาดเท่ากับอาร์เรย์อินพุตของคุณ

 int check_list[SIZE_OF_INPUT];
 for(n elements in checklist)
     check_list[i]=0;    //initialize to zero

2 สแกนอาร์เรย์อินพุตของคุณและเพิ่มจำนวนในอาร์เรย์ด้านบน

for(i=0;i<n;i++) // every element in input array
{
  check_list[a[i]]++; //increment its count  
}  

3 ตอนนี้สแกนอาร์เรย์ check_list และพิมพ์รายการที่ซ้ำกันครั้งเดียวหรือหลายครั้งที่ซ้ำกัน

for(i=0;i<n;i++)
{

    if(check_list[i]>1) // appeared as duplicate
    {
        printf(" ",i);  
    }
}

แน่นอนว่าต้องใช้พื้นที่สองเท่าของโซลูชันที่ให้ไว้ข้างต้น แต่ประสิทธิภาพของเวลาคือ O (2n) ซึ่งโดยทั่วไปคือ O (n)