Réorganiser un tableau de sorte que chaque élément impair soit supérieur à son élément précédent

Nous avons un tableau de types entiers positifs, supposés être arr[], de n'importe quelle taille. La tâche consiste à réorganiser le tableau de manière à ce que tous les éléments aux positions d'index impaires aient des valeurs supérieures à celles des éléments aux positions d'index paires et à imprimer le résultat.

Jetons un coup d'œil à différentes situations d'entrée et de sortie :

Entrée − int arr[] = {2, 1, 5, 4, 3, 7, 8}

Sortie − Tableau avant le tri : 2 1 5 4 3 7 8 Réorganisez le tableau de manière à ce que chaque élément impair soit supérieur à son élément précédent : 1 4 2 5 3 8 7

Explication - On nous donne un tableau d'entiers de taille 7. Maintenant, si l'élément à l'indice pair est plus grand, nous échangerons l'élément à l'indice pair et l'élément à l'indice impair

Arr[0] > arr[1] = call swap = {1, 2, 5, 4, 3, 7, 8}
Arr[2] > arr[3] = call swap = {1, 2, 4, 5, 3, 7, 8}
Arr[6] > arr[5] = call swap = {1, 2, 4, 5, 3, 8, 7}
Arr[2] > arr[1] = call swap = {1, 4, 2, 5, 3, 8, 7}

input− int arr[] = {3, 2, 6, 9}

output− Array avant le tri : 3 2 6 9 Le réarrangement d'un tableau de telle sorte que chaque élément indexé impair soit supérieur au précédent est : 2 3 6 9

Explication − on nous donne un tableau entier de taille 4. Maintenant, nous allons échanger les éléments d'index pair avec les éléments à un index impair si les éléments indexés pairs sont plus grands, c'est-à-dire Arr[0] > arr[1] = call swap = {2, 3, 6, 9} Pas besoin d'appeler davantage la méthode swap car tous les éléments aux positions satisfont le conditions

L'approche utilisée dans le programme ci-dessous est la suivante

• Entrez un tableau d'éléments de type entier et calculez la taille d'un tableau.

• Imprimez le tableau avant l'arrangement et appelez la fonction Réarrangement(arr, taille)

• À l'intérieur de la fonction Rearrangement(arr, size)

  • Créez une variable de type entier, disons ptr et définissez-la avec la taille-1.

  • Démarrez la boucle FOR, de i à 0 jusqu'à i moins que ptr et i = i + 1. À l'intérieur de la boucle, vérifiez si arr[i] est supérieur à arr[i+1] puis appelez swap(arr[i], arr[i+1]).

  • Vérifiez SI taille & 1 puis démarrez la boucle FOR de i à ptr jusqu'à ce que i soit supérieur à 0 et i = i - 2. À l'intérieur de la boucle, vérifiez SI arr[i] supérieur à arr[i - 1] puis appelez swap(arr[i] , arr[i-1])

• Imprime le tableau après le réarrangement des valeurs d'un tableau.

Exemple

#include <iostream>
using namespace std;
void Rearrangement(int arr[], int size){
   int ptr = size - 1;
   for(int i = 0; i < ptr; i = i+2){
      if(arr[i] > arr[i+1]){
         swap(arr[i], arr[i+1]);
      }
   }
   if(size & 1){
      for(int i = ptr; i > 0; i = i-2){
         if(arr[i] > arr[i-1]){
            swap(arr[i], arr[i-1]);
         }
      }
   }
}
int main(){
   //input an array
   int arr[] = {2, 1, 5, 4, 3, 7, 8};
   int size = sizeof(arr) / sizeof(arr[0]);
   //print the original Array
   cout<<"Array before Arrangement: ";
   for (int i = 0; i < size; i++){
      cout << arr[i] << " ";
   }
   //calling the function to rearrange the array
   Rearrangement(arr, size);
   //print the array after rearranging the values
   cout<<"\nRearrangement of an array such that every odd indexed element is greater than it previous is: ";
   for(int i = 0; i < size; i++){
      cout<< arr[i] << " ";
   }
   return 0;
}

Sortie

Si nous exécutons le code ci-dessus, la sortie suivante sera être généré

Array before Arrangement: 2 1 5 4 3 7 8
Rearrangement of an array such that every odd indexed element is greater than it previous is: 1 4 2 5 3 8 7

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!