Algoritma pembalikan untuk putaran tatasusunan yang ditulis dalam C++

Dalam masalah yang diberikan, kita mempunyai tatasusunan dan kita perlu memutarkan tatasusunan dengan elemen d menggunakan algoritma penyongsangan, contohnya −

Input : arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2
Output : arr[] = [3, 4, 5, 6, 7, 1, 2]
Explanation : As you can see we have to rotate this array by d = 2 but our main task is to achieve this by using a reversal technique.

# 🎜🎜 #Kami melakukan beberapa pengiraan pada putaran tatasusunan dengan teknik penyongsangan dan membuat kesimpulan:

Pertama, kami terbalikkan elemen d pertama tatasusunan.
• Kedua, kita terbalikkan elemen yang tinggal.
• Ketiga, kami membalikkan keseluruhan tatasusunan.

Dengan menggunakan tiga langkah ini, kita boleh mendapatkan tatasusunan berputar.

Kaedah penyelesaian

Dalam masalah ini, pertama, kita akan menulis fungsi yang membalikkan unsur-unsur sekarang kita mengikuti langkah-langkah di atas.

Contoh

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

void reverseArray(int arr[], int start, int end) { // our reversal algorithm
   while (start < end) { // if start becomes equal to end we break the loop
      int temp = arr[start];
      arr[start] = arr[end];
      arr[end] = temp;
      start++;
      end--;
   }
   return ;
}
void Rotate(int arr[], int d, int n) { // rotation function
   if (d == 0) // no rotation required
      return;
   d = d % n; // when d becomes equal to n so our array comes to its original form
   reverseArray(arr, 0, d - 1); // reversing first d elements
   reverseArray(arr, d, n - 1); // reversing the remaining elements
   reverseArray(arr, 0, n - 1); // reversing the whole array

   return ;
}
int main() {
   int arr[] = { 1, 2, 3, 4, 5, 6, 7 }; // given array
   int n = sizeof(arr) / sizeof(arr[0]); // size of our array
   int d = 2;
   Rotate(arr, d, n);
   for(int i = 0; i < n; i++) // printing the array
      cout << arr[i] << " ";
   cout << "\n";
   return 0;
}

Output

3 4 5 6 7 1 2

Penjelasan kod di atas

#🎜 mula-mula buat kaedah di atas🎜 Teknik pembalikan, ia akan mengambil tiga parameter iaitu tatasusunan, indeks mula dan indeks tamat dan membalikkan tatasusunan kita dari kedudukan mula ke kedudukan akhir. Memandangkan kami telah membangunkan algoritma sebelum ini, kami akan menggunakan fungsi ini untuk menggunakan algoritma. Pertama, kita membalikkan elemen d pertama. Kemudian, kita membalikkan elemen yang tinggal, dan akhirnya, kita membalikkan keseluruhan tatasusunan. Akibatnya, tatasusunan kami diputar oleh kedudukan d. Dalam fungsi putaran, kita tetapkan d kepada d % n. Ini kerana jika kita memutarkan n elemen pertama tatasusunan, kita akan mendapat jawapan yang sama seperti sebelumnya, jadi kita mengambil d modulo n.

Kesimpulan

Dalam artikel ini, kami menyelesaikan masalah menggunakan algoritma penyongsangan untuk putaran tatasusunan. Kami juga mempelajari program C++ dan cara lengkap (biasa) untuk menyelesaikan masalah ini. Kita boleh menulis program yang sama dalam bahasa lain seperti C, Java, Python dan bahasa lain. Semoga artikel ini bermanfaat kepada anda.

Atas ialah kandungan terperinci Algoritma pembalikan untuk putaran tatasusunan yang ditulis dalam C++. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!