Dans ce tutoriel, nous allons implémenter l'algorithme de tri par sélection en Python. Il s’agit d’un algorithme assez simple utilisant moins d’échanges.

Dans cet algorithme, nous sélectionnons le plus petit élément d'un tableau non trié à chaque passe et échangeons avec le début du tableau non trié. Ce processus se poursuivra jusqu'à ce que tous les éléments soient placés au bon endroit. Il s’agit d’un algorithme de tri par comparaison simple et sur place.

moyenne vs moyenne

Fonctionnement du tri par sélection

Voici les étapes pour expliquer le fonctionnement du tri Sélection en Python.

Prenons un tableau non trié pour appliquer l'algorithme de tri par sélection.

[30, 10, 12, 8, 15, 1]

Étape 1: Obtenez la longueur du tableau.

longueur = len (tableau) → 6

Étape 2: Tout d’abord, nous définissons le premier élément comme élément minimum.

10 sur 50

Étape 3: Comparez maintenant le minimum avec le deuxième élément. Si le deuxième élément est plus petit que le premier, nous l'attribuons au minimum.

Encore une fois, nous comparons le deuxième élément au troisième et si le troisième élément est plus petit que le deuxième, attribuons-le comme minimum. Ce processus se poursuit jusqu'à ce que nous trouvions le dernier élément.

Étape 4: Après chaque itération, l'élément minimum est échangé devant le tableau non trié.

Étape - 5 : Les deuxième à troisième étapes sont répétées jusqu'à ce que nous obtenions le tableau trié.

Algorithme de tri par sélection

L'algorithme de tri par sélection est le suivant.

Algorithme

 selection_sort(array) repeat (0, length - 1) times set the first unsorted element as the minimum for each of the unsorted elements if element <currentminimum set element as new minimum swap with first unsorted position end selection_sort < pre> <h2>Selection Sort Program using Python</h2> <p>The following code snippet shows the selection sort algorithm implementation using Python.</p> <p> <strong>Code -</strong> </p> <pre> def selection_sort(array): length = len(array) for i in range(length-1): minIndex = i for j in range(i+1, length): if array[j] <array[minindex]: minindex="j" array[i], array[minindex]="array[minIndex]," array[i] return array print('the sorted is: ', selection_sort(array)) < pre> <p> <strong>Output:</strong> </p> <pre> The sorted array is: [3, 6, 9, 21, 33] </pre> <p> <strong>Explanation -</strong> </p> <p>Let&apos;s understand the above code -</p> <ul> <li>First, we define the <strong>selection_sort()</strong> function that takes array as an argument.</li> <li>In the function, we get the length of the array which used to determine the number of passes to be made comparing values.</li> <li>As we can see that, we use two loops - outer and inner loop. The outer loop uses to iterate through the values of the list. This loop will iterate to 0 to (length-1). So the first iteration will be perform (5-1) or 4 times. In each iteration, the value of the variable i is assigned to the variable</li> <li>The inner loop uses to compare the each value of right-side element to the other value on the leftmost element. So the second loop starts its iteration from i+1. It will only pick the value that is unsorted.</li> <li>Find the minimum element in the unsorted list and update the minIndex position.</li> <li>Place the value at the beginning of the array.</li> <li>Once the iteration is completed, the sorted array is returned.</li> <li>At last we create an unsorted array and pass to the <strong>selection_sort()</strong> It prints the sorted array.</li> </ul> <h2>Time Complexity of Selection Sort</h2> <p>Time complexity is an essential in term of how much time an algorithm take to sort it. In the selection sort, there are two loops. The outer loop runs for the n times (n is a total number of element).</p> <p>The inner loop is also executed for n times. It compares the rest of the value to outer loop value. So, there is n*n times of execution. Hence the time complexity of merge sort algorithm is O(n<sup>2</sup>).</p> <p>The time complexity can be categorized into three categories.</p> <hr></array[minindex]:></pre></currentminimum>

Explication -

Comprenons le code ci-dessus -

• Dans un premier temps, nous définissons le sélection_sort() fonction qui prend le tableau comme argument.
• Dans la fonction, nous obtenons la longueur du tableau qui sert à déterminer le nombre de passes à effectuer en comparant les valeurs.
• Comme nous pouvons le voir, nous utilisons deux boucles : une boucle externe et une boucle interne. La boucle externe utilise pour parcourir les valeurs de la liste. Cette boucle itérera de 0 à (longueur-1). La première itération sera donc effectuée (5-1) soit 4 fois. A chaque itération, la valeur de la variable i est affectée à la variable
• La boucle interne permet de comparer chaque valeur de l'élément de droite à l'autre valeur de l'élément le plus à gauche. La deuxième boucle commence donc son itération à partir de i+1. Il ne sélectionnera que la valeur non triée.
• Recherchez l'élément minimum dans la liste non triée et mettez à jour la position minIndex.
• Placez la valeur au début du tableau.
• Une fois l'itération terminée, le tableau trié est renvoyé.
• Enfin, nous créons un tableau non trié et passons au sélection_sort() Il imprime le tableau trié.

Complexité temporelle du tri par sélection

La complexité temporelle est un élément essentiel en termes de temps nécessaire à un algorithme pour le trier. Dans le tri par sélection, il y a deux boucles. La boucle externe s'exécute n fois (n est un nombre total d'éléments).

La boucle interne est également exécutée n fois. Il compare le reste de la valeur à la valeur de la boucle externe. Il y a donc n*n fois d’exécution. Par conséquent, la complexité temporelle de l’algorithme de tri par fusion est O(n²).

bordure CSS

La complexité temporelle peut être classée en trois catégories.