Sortir Cepat di C ++: Panduan Lengkap – Codewithaden

Suka Gabungan , Jenis Cepat juga merupakan algoritma penyortiran rekursif yang menggunakan metode Divide and Conquers. Harap baca tutorial gabungan kami terlebih dahulu jika Anda tidak tahu apa itu Divide and Conquer.

Ilmuwan komputer Inggris Tony Hoare mengembangkan algoritma Quicksort pada tahun 1959 dan menerbitkannya pada tahun 1961. Quicksort adalah algoritma yang digunakan di sebagian besar kompiler di dalamnya menyortir().

Sortir Cepat di C ++

Dalam jenis C ++ cepat, pertama, kita perlu memilih nilai pivot (Lebih disukai elemen terakhir dari array). Kemudian, kami mengatur Nilai yang lebih kecil menuju sisi kiri pivot dan lebih tinggi Nilai ke arah kanan pivot .

Kedua operasi ini dilakukan secara rekursif sampai hanya satu elemen yang tersisa di kedua sisi pivot. Dengan kata lain, algoritma Quicksort adalah sebagai berikut.

Quicksort adalah algoritma penyortiran yang biasa digunakan dalam ilmu komputer. Misalnya, Quicksort adalah algoritma Divide and Conquers.

Ini menciptakan dua array kosong untuk menahan elemen kurang dari nilai pivot dan elemen yang lebih signifikan daripada nilai pivot dan kemudian secara rekursif mengurutkan sub-array.

Ada dua operasi dasar dalam algoritma, bertukar item di tempat dan mempartisi bagian array.

Contoh algoritma quicksort

Sekarang, lihat contoh berikut.

Misalkan kita diberi array.

15 85 32 21 24

Jadi di sini, kami pivot = 24. Sekarang, array akan mengikuti setelah mengatur semua elemen yang lebih kecil ke sisi kiri 24 dan elemen yang lebih signifikan ke sisi kanan 24.

Quick

Jadi setelah umpan pertama, 24 ditempatkan di posisi yang benar. Sekarang, kami akan kembali melakukan operasi partisi ke sub-array kiri dan sub-array kanan, dan sebagainya.

Jadi, operasinya akan berada di setiap langkah seperti berikut.

C++

Apa yang terjadi di sini adalah:

Pertama, itu disebut quicksort (array, start_index, end_index), kemudian partisi () dipanggil, dan mengatur angka yang lebih kecil di sisi kiri pivot dan angka yang lebih tinggi di sisi kanan pivot. Dan lagi, quicksort () disebut rekursif. Jadi dengan cara ini, akhirnya kami mendapat 15.

Example

Setelah itu, quicksort () mengembalikan subarray yang diurutkan pada setiap langkah, dan sekali lagi, operasi di subarray kanan dilakukan seperti gambar di bawah ini.

Quick

Jadi, di sini saya telah menunjukkan kepada Anda bagaimana quicksort dilakukan secara rekursif dalam tiga gambar ini.

  1. Temukan elemen “pivot” dalam array. Item pivot adalah dasar untuk perbandingan untuk satu putaran.
  2. Mulai pointer (pointer kiri) di item pertama dalam array.
  3. Mulai pointer (penunjuk kanan) di item terakhir di array.
  4. Sementara nilai di pointer kiri di array kurang dari nilai pivot, pindahkan pointer kiri ke kanan (tambahkan 1). Lanjutkan sampai nilai di pointer kiri lebih besar dari atau sama dengan nilai pivot.
  5. Sementara nilai di pointer kanan di array lebih besar dari nilai pivot, pindahkan pointer kanan ke kiri (kurangi 1). Lanjutkan sampai nilai di pointer kanan kurang dari atau sama dengan nilai pivot.
  6. Jika pointer kiri kurang dari atau sama dengan pointer kanan, tukar nilai dalam array di lokasi ini.
  7. Pindahkan pointer kiri ke kanan dengan satu dan pointer kanan ke kiri oleh satu.
  8. Jika pointer kiri dan penunjuk kanan tidak bertemu, lanjutkan ke langkah 1.

Kode semu untuk algoritma quicksort

Quicksort (a, start, end)

  1. jika Mulai
  2. P_indx = partisi (a, start, end)
  3. Quicksort (a, start, p_indx-1)
  4. Quicksort (a, p_indx +1, end)
  5. KELUAR

Partisi (a, start, end)

  1. Atur pivot = a [end]
  2. Atur p_indx = mulai
  3. Ulangi Langkah 4 hingga 7 Untuk J = Mulai ke Akhir – 1
  4. Jika A [j] <= pivot
  5. Exchange a [p_index] dengan [j]
  6. Atur p_index = p_index+1

[Akhir IF Block]

  1. Exchange a [p_index] dengan [akhir]

[Akhir untuk Loop]

8. Kembalikan p_index

C ++ Quicksort Program

Lihat kode C ++ Quicksort di bawah ini.

#include
using namespace std;
int partition(int *a,int start,int end)
{
    int pivot=a[end];
    //P-index indicates the pivot value index
    
    int P_index=start;
    int i,t; //t is temporary variable
    
    //Here we will check if array value is 
    //less than pivot
    //then we will place it at left side
    //by swapping 
    
    for(i=start;i>n;
        int a[n];
        cout<<"Enter the array elements:\n";
        for(int i=0;i>a[i];
       }
      Quicksort(a,0,n-1);
      cout<<"After Quick Sort the array is:\n";
      for(int i=0;i

Output di bawah ini.

Quicksort

Kompleksitas waktu untuk quicksort

Kasus terburuk terjadi ketika proses partisi selalu memilih item terbesar atau terkecil sebagai pivot dan kompleksitas Kasus terburuk: o (n^2).

Kasus terbaik terjadi ketika proses partisi selalu memilih elemen tengah sebagai pivot. Dan kompleksitas Kasus Terbaik: o (n).

Kasus rata -rata berarti ketika tidak ada pohon yang seimbang atau kasus terburuk. Kompleksitas dari Kasus rata -rata: (n log n).

Mengapa quicksort over gabungan?

Kompleksitas waktu untuk quicksort adalah o (n ). Nya kasus rata-rata waktu berjalan adalah o (nlog (n)), tetapi itu kasus terburuk adalah o (n ), yang terjadi ketika Anda menjalankannya di daftar yang berisi beberapa item unik.

Pengacakan mengambil O (n). Tapi, tentu saja, itu tidak mengubah kasus terburuknya, dan itu hanya mencegah pengguna jahat membuat jenis Anda membutuhkan waktu lama.

Quicksort lebih populer karena itu:

  1. Itu ada (gabungan mortir membutuhkan memori ekstra linier untuk beberapa elemen untuk diurutkan).
  2. Ini memiliki konstanta tersembunyi kecil.

Itu untuk jenis C ++ cepat.

Artikel ini berasal dari website Winpoin, dan kemudian diterjemahkan ke bahasa indonesia, baca artikel asli disini

Leave a Reply

Your email address will not be published. Required fields are marked *