Je connais très bien la méthode de tri enseignée par le professeur, je n'ai pas eu le temps de tout expliquer mais je l'améliore petit à petit, je voudrais vous encourager !
#include <stdio.h>
#define MAX 10typedef int ARR[MAX];
typedef int Elementype;
void swap(ARR arr,int i,int j);//Échanger la valeur du paramètre
void insert(ARR arr);//Insérer un sort
void shell(ARR arr); // Hill sort
void print(ARR arr);//Fonction d'impression
void heap(ARR arr);//Heap sort body
void heapadjust(ARR arr,int n,int m);//Heap sort initialization functionvoid mergesort2 (ARR arr, int gauche, int droite) // tri par fusion récursif
void swap(ARR arr,int i,int j)//交换函数
{ int temp = arr[i]; arr[je] = arr[j]; arr[j] = temp; }
void insert(ARR arr)//Insertion sort
{ int i,j; for(i = 1;i < MAX;i++) { if(arr[i-1] > arr[i])//Jugez la différence entre ceci bit et le précédent La taille d'un bit { Type d'élément temp = arr[i];//Enregistre la position à déterminer pour(j = i - 1;j >= 0;j--) { if(arr[j] > temp) arr[j +1] = arr[j];//Si la position précédente est supérieure à la position suivante, écrasez le bit précédent par le bit suivant et bouclez ce jugement sinon break; } arr [ j + 1 ] = temp;//Jusqu'à ce qu'il ne soit pas supérieur à la position à juger, attribuez-le au bit suivant de cette position print(arr); } } }
void shell (ARR arr) // Tri Hill, basé sur le tri par insertion, regroupe les tableaux en séquence, effectue un tri par insertion dans le groupe, puis trie sous moins de groupes jusqu'à ce que le nombre de groupes soit un (groupe Le nombre est 2 ^ n + ou -1, c'est-à-dire 1,3,5,7,9,15,17....)
{ int a[] = {1,3,5};//enregistrer le nombre de groupes int k = 2 ; int step = a[k];//Utiliser un nombre différent de groupes dans la boucle suivante int i,j; while(k >= 0) { for(i = step;i < MAX;i++) { if (arr [i - step] > arr[i])//Si divisé en cinq groupes, les 0ème et 5ème positions sont un groupe, triés, les 1ère et 6ème positions sont un groupe, triés.... . { Elementype temp = arr [i]; for(j = i-step;j >= 0;j -= step)//La taille du pas est le nombre de groupes. Deux éléments du même groupe sont séparés par pas. Utilisez le tri par insertion pour déterminer les pensées { si(arr[j] > temp) {
arr[j + step] = arr[j];
}
else
break;
}
arr[j+step] = temp;
}
}
step = a[--k];//Effectuer le tri par insertion du numéro de groupe suivant
print( arr );
}
}
void heapadjust(ARR arr,int n,int m)
{ Elementype temp = arr[n];//Enregistre la valeur du parent int i; for(i = 2*n+1;i <= m;i = 2 *i +1) { if(i < m && arr[i] < arr[i + 1])//Comparez la taille des sous-arbres gauche et droit i++; if(arr[i] < temp)//Comparez les plus grand avec le parent break ; arr[n] = arr[i];//Si l'enfant est grand, l'enfant écrase le parent n = i; } arr[n] = temp;//Mette la valeur du plus petit parent à la position de l'enfant }
void heap(ARR arr)
{ int i; for(i = (MAX-2)/2;i >= 0;i--)//Initialisation { heapadjust(arr,i,MAX-1);//Traitement du tas , formant finalement un grand tas supérieur } print(arr); printf("**************\n"); for(i = MAX-1;i > 0;i-- ) { swap(arr,0,i);//Mettre la valeur maximale à la fin du heapadjust(arr,0,i-1);//Réduire la plage de l'arbre pour former à nouveau un grand tas supérieur (en excluant le maximum valeur) print(arr); } }
void meige(ARR arr,int left,int mid,int right)//Merge
{ int len = droite-gauche+1; Elementype temp[len]; int k = 0; int i = left;//of the groupe précédent Le premier int j = mid+1;//Le premier while(i <= mid && j <= right) { if(arr[i] < arr[j]) { temp[k++] = arr[i++] ;//Comparez le premier nombre, placez le plus petit dans le tableau, puis prenez le nombre suivant pour comparaison} else { temp [k++] = arr[j++];//Par exemple, le premier nombre est supérieur au suivant one Le premier du groupe est petit. Une fois placé dans le tableau, i++ compare ce dernier avec le groupe suivant. Puisque le tri au sein du groupe est terminé, seuls les nombres entre les groupes sont triés} } while ( i < = mid) { temp[ k++] = arr[i++];//Mettez les nombres restants dans le tableau }
while(j <= right)
{ temp[k++] = arr[j++];//Mettre les nombres restants dans le tableau } for(i = 0;i < len;i++) arr[left+i] = temp[ i ];//Placer le tableau temporaire dans le tableau d'origine }void mergesort1(ARR arr)//Tri par fusion non récursif
{ int left,right,mid; int i; for(i = 1;i < MAX;i *= 2) { left = 0; while(left + i < MAX)//La contrainte est qu'au moins un groupe peut être formé dans le tableau pour le tri { mid = left+i-1;//i est la longueur de chaque groupe, mid est la queue du premier groupe right = ( mid+i )<(MAX-1)?(mid+i):(MAX-1);//right est la marque de queue du deuxième groupe merge( arr,left,mid,right);//Appeler la fusion fonction pour fusionner deux consécutifs La disposition des tailles entre les groupes, la première fois est le tri des éléments adjacents, la deuxième fois est le tri de deux groupes, le tri des groupes gauche = droite+1; } print( arr ) ; } }
void mergesort2(ARR arr, int left, int right)//Tri par fusion récursive, l'idée est de fusionner et trier au sein du groupe, puis de fusionner et trier entre les groupes { if (left == right)
{ return ; } int mid = (left+right)/2; mergesort2(arr,left,mid);//Le demi-groupe gauche est trié au sein du groupe, et le tri entre les éléments est progressivement appelé et la valeur de retour est appelée mergesort2(arr, mid + 1, right); merge(arr,left,mid,right);//Appelle la fonction de tri par fusion print(arr); }