Melaksanakan pengisihan gabungan dalam C++ menggunakan multithreading

Kami mendapat tatasusunan integer yang tidak diisih. Tugasnya adalah untuk mengisih tatasusunan menggunakan teknik isihan gabungan yang dilaksanakan melalui pelbagai benang

MERGE SORT

Merge sort ialah teknik menyusun berdasarkan teknik bahagi dan takluk di mana kita akan membahagi tatasusunan kepada Ambil dua bahagian yang sama dan gabungkannya dengan cara yang disusun.

Algoritma untuk melaksanakan isihan gabungan ialah

• Menyemak sama ada terdapat elemen

• #🎜🎜 🎜🎜 #Jika tidak, bahagikan data kepada separuh secara rekursif sehingga ia tidak boleh dipecah lagi.

• Akhir sekali, gabungkan senarai yang lebih kecil ke dalam senarai baharu dalam susunan yang disusun.

Multi-threading

Dalam sistem pengendalian,

Thread ialah proses ringan yang bertanggungjawab untuk melaksanakan beberapa tugas. Benang berkongsi sumber biasa untuk melaksanakan tugas secara serentak.

Multi-threading ialah pelaksanaan multitasking Kita boleh menjalankan berbilang thread pada satu pemproses untuk melaksanakan tugas secara serentak. Ia memecahkan operasi tertentu dalam satu aplikasi kepada benang yang berasingan. Setiap benang boleh berjalan selari.

Contohnya:

Dalam −int arr[] = {3, 2, 1, 10, 8, 5, 7, 9 , 4}

Output− Tatasusunan yang diisih ialah: 1, 2, 3, 4, 5, 7, 8, 9, 10#🎜 #

Penjelasan

- Kami mendapat tatasusunan yang tidak diisih dengan nilai integer. Sekarang kita akan mengisih tatasusunan menggunakan jenis cantuman berbilang benang.

In

−int arr[] = {5, 3, 1, 45, 32, 21, 50}#🎜🎜 Output p>−Susun atur diisih ialah: 1, 3, 5, 21, 32, 45, 50

Penjelasan

−Kami memberikan tatasusunan Tidak diisih. Sekarang kita akan mengisih tatasusunan menggunakan jenis cantuman berbilang benang.

Kaedah yang digunakan dalam atur cara di bawah adalah seperti berikut -

Kami akan mula menjana nombor rawak dengan menggunakan kaedah rand() dalam C++ STL .

• Buat tatasusunan jenis pthread_t, iaitu P_TH[thread_size].

• Mulakan gelung FOR dari i ke 0 sehingga i kurang daripada saiz benang. Di dalam gelung, kaedah pthread_create(&P_TH[i], NULL, Sorting_Threading, (void*)NULL) dipanggil untuk mencipta thread dengan nilai tatasusunan yang diberikan.
Panggil fungsi sebagai tatasusunan gabungan (0, (saiz / 2 - 1) / 2, saiz / 2 - 1), combine_array (saiz / 2, saiz / 2 + (saiz-1-saiz/2)/2, saiz-1) dan merge_array(0, (saiz-1)/2, saiz-1)

• #🎜 🎜 #Cetak tatasusunan yang diisih yang disimpan dalam jenis integer arr[].

• Fungsi dalaman terbatal* Sorting_Threading(void* arg)

#🎜🎜🎜🎜##🎜🎜 kepada pembolehubah dari__setkan++ Set_val pertama * (saiz / 4), hujung ialah (set_val + 1) * (saiz / 4) - 1, mid_val ialah pertama + (akhir - pertama) / 2
# 🎜 🎜#Semak JIKA dahulu kurang daripada akhir kemudian panggil Sorting_Threading(first, mid_val), Sorting_Threading(mid_val + 1, end) dan combine_array(first, mid_val, end);

• #🎜 🎜 #
• Fungsi dalam batal Sorting_Threading(int first, int end)

Isytiharkan pembolehubah sebagai mid_val pertama hingga pertama + (akhir -val pertama) / 2

• Semak jika JIKA kurang daripada akhir dahulu, kemudian panggil Sorting_Threading(first, mid_val), Sorting_Threading(mid_val + 1, end) dan merge_valray(first, mid_valray , end)# 🎜🎜#

  Internal void merge_array(int first, int mid_val, int end)

  • #🎜 🎜## 🎜🎜#Isytiharkan pembolehubah sebagai int* mula kepada int baharu[mid_val - first + 1], int* last to new int[end - mid_val], temp_1 to mid_val - first + 1, temp_2 to end - mid_val, i , j , k ke dahulu.

• Mulakan gelung FOR dari i ke 0 sehingga i kurang daripada temp_1. Di dalam gelung, tetapkan mula[i] kepada arr[i + pertama].
  • Mulakan gelung FOR dari i ke 0 sehingga i kurang daripada temp_2. Di dalam gelung, tetapkan [i] terakhir kepada arr[i + mid_val + 1]
    li>set i kepada j kepada 0. Mulakan gelung apabila i kurang daripada temp_1 dan j kurang daripada temp_2. Sementara itu, semak jika JIKA mula[i] kurang daripada yang terakhir[j], kemudian tetapkan arr[k++] untuk memulakan[i++]. Jika tidak, tetapkan arr[k++] = last[j++]
  Mula apabila i kurang daripada temp_1, kemudian tetapkan arr[k++] = mula[i++]. Mulakan apabila j kurang daripada temp_2, kemudian tetapkan arr[k++] kepada last[j++] 🎜🎜#Output

  • Jika kita menjalankan kod di atas, ia akan menghasilkan output berikut

    rreee#🎜 🎜#

Atas ialah kandungan terperinci Melaksanakan pengisihan gabungan dalam C++ menggunakan multithreading. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!