Aujourd'hui, cela parle principalement de certains algorithmes organisés dans la structure de données.

Supposons maintenant qu'il y a n enregistrements {R1, R2, .. rn}, les mots-clés correspondants sont {K1, K2, .. KN}, besoin d'identifier un, 2, .. N, un P1, P2, .. PN, .. PN, Faire les mots-clés correspondants KP1 & LT; = Kp2 & lt = kp3 & lt; = .. & Lt; Lien KPN, même si la séquence devient une chaîne triée dans un mot-clé, une telle manipulation s'appelle le tri.

1. Disposer la stabilité

Le mot clé est divisé en mot-clé principal et le deuxième mot clé, le mot clé principal n'est qu'un, mais le nombre de fois pas limite. Étant donné que les arrangements ne sont pas seulement pour la clé principale, il sera trié par le deuxième mot clé. Il peut y avoir deux mots clés ou plus, tels que deux mots-clés ou plus dans la séquence de séquence, seront disposés et les résultats de tri seront uniques. Si les deux valeurs de chaîne sont disposées devant le mot-clé, lors du tri en tri, un VAvant devant le type B et stable; Si l'arrangement A est gagné plus tard, le type est instable.
2. Organisez-le dans OCEM

est dans l'ensemble du processus d'agencement, toutes les copies enregistrées seront disposées en mémoire. Le routage externe est le nombre d'enregistrements enregistrés comme trop et ne peut pas être placé dans la même mémoire simultanément et que tout le processus d'organisation nécessite beaucoup de données d'échange internes et externes.

3. Type d'agencement d'algorithme

Organisez un total de quatre types, sept algorithmes, types spécifiques comme suit:

Arrangez la classe

Insérez des classes de mise au point dans l'insertion de ces deux mots, à savoir une séquence d'ordre, l'insertion de nouveaux mots-clés, par mot-clé à insérer avec des chaînes. Il existe des mercredis que chaque valeur est comparée, trouvant la position d'insertion appropriée, de sorte que le Une séquence totale après l'insertion est toujours ordonnée. L'insertion directe, le pliage et l'explication de cette classe appartiennent à cette classe.

Organisez des cours d'échange

L'échange focal agencé est échangé avec un échange, en épargnant de comparer la taille entre les deux valeurs puis de l'échange de la position des deux valeurs. Répétez cette procédure jusqu'à ce que la fin de la chaîne entière soit disposée. Arrangez des bulles et organiser rapidement appartenir rapidement à ce type disposé.

Choisissez d'organiser la classe

La mise au point de choisir d'organiser des classes est sélectionnée dans des séquences sélectionnées à partir de la séquence de la clé minimale (ou maximale), l'échangeant et la Premier mot-clé (ou final) dans la chaîne, le mot-clé minimum (ou maximum) est placé dans un emplacement ordonné, continuant la boucle, jusqu'à ce que la chaîne de jeu complète soit disposée. Séquences simples et empilement appartiennent à ce type de classification.

Sort Monarch

La classification unifiée consiste à combiner deux séquences ou plus dans une nouvelle séquence


, et fonctionne pour organiser des algorithmes

Pour organiser des structures de table hebdomadairesParce que cette structure sera utilisée pour suivre toutes les structures consécutives décrites.

Le fonctionnement le plus courant de l'agencement est l'échange de deux éléments de la matrice et nous écrivons ce processus de conversion à une fonction après la commodité.
#define MAXSIZE 10 //要排序数组个数最大值typedef struct{ int r[MAXSIZE + 1]; //用来存储要排序数组 int length; //用来记录顺序表长度}
II. Trier inserts

void swap(SqList *L,int i,int j){ int temp = L->r[i]; L->r[i] = L->r[j] L->r[j] = temp;} 1. Organisez l'insertion directement

Tri directement à la balise lorsque nous jouons au poker, nous avons généralement une carte et la carte est insérée directement dans l'avant. Bonne séquence série. Le processus d'insertion spécifique est le suivant:

Du premier élément, le premier élément par défaut est une chaîne

pour retirer l'élément suivant comme insert d'élément, puis après le nombre Les numéros dans les numéros sont déplacés, jusqu'à ce que non requis, le nouvel élément est inséré dans le poste vacant
Répétez l'étape précédente jusqu'à ce que tout le traitement des prix de la chaîne soit inséré
. est comme suit:

2. Ordre semi-finale plié

void Insertsort(int R[],int n)//R[]用来存放待插入排序的所有值{ int i,j; int temp; //用来存放待插入值 for(i = 1;i < n;++i) { temp = R[i];//待插入值为序列R[]中的第i个值 j = i - 1;//待插入数值前一位 while(j>=0&&temp<R[j])//当待插入值temp小于它前面的数时，前面的数就需要后移 { R[j+1] = R[j]; --j;//通过前移遍历已排序好的序列中的每一个值 } R[j+1] = temp;//将temp插入到R[j+1]的位置 }} Atelier de pliage amélioré sur la base d'un arrangement d'insertion directe, l'insertion directe est une valeur en transmission au tri et le pliage d'ordre arrangé en insérant la moitié de la position actuelle, est en fait une méthode de recherche racine dans nos études secondaires.
3. Hill disposé

Arrangez-vous directement dans une heure très élevée, plus, si les données sont essentiellement disposées, nous devons simplement faire une petite quantité d'exploitation d'insertion; Soit si le journal est trié comme petit, la séquence d'insertion efficace est différente. Toutefois, les données dans la pratique sont difficiles à respecter ces deux conditions. Les gens doivent donc organiser des données dans des données pour répondre à ces deux conditions.

Comment mettre en place un nombre rare d'enregistrements? La méthode de comparaison directe est le nombre d'enregistrements d'origine des enregistrements, qui est divisé en plusieurs goûts de projet, de sorte que le nombre d'enregistrements est agencé de moins, puis trier l'insert peut être utilisé directement dansChaque groupe et lorsque la chaîne entière est essentiellement ordonnée, triée directement de tous les enregistrements. Nous appelons cela comme un arrangement de colline.

Le problème actuel est la manière dont le groupe de données d'origine. Si la distance directe ou autre est coupée, telle que la séquence d'origine est {9, 1, 5, 8, 3, 7, 4, 6, 2}, coupez-les maintenant en tricy, {9, 1, 5}, { 8, 3, 7}, {4, 6, 2} et trois groupes utilisés à tour sont insérés directement, devenant {1, 9}, {3, 7, 8}, {2, 4, 6}, puis renforcez trois groupes en {1, 5, 9, 3, 7, 8, 2, 4, 6} Cette séquence est toujours très désordonnée, mais aussi pour insérer la séquence sera insérée une fois, mais la commande et la séquence d'origine après la coupe sont Pas trop différent, principalement parce que nous coupons la coupe isométrique. Pour éviter ce cas après la découpe, nous avons démarré le colis avec un type de distance de séparation, telle que le nombre d'options 1, 3, 5 positions sous forme d'épisode 2, 4, 6 positions sous forme d'un tel procédé de saut. Le code est le suivant:

III. Exchange de signe

1. Ordre de Bubling

void ShellSort(SqList *L){ int i,j; int incremrnt = L->length; do { incremrnt = increment/3+1; //间隔序列 for(i=increment+1;i<L-length;i++) { if(L->r[i]<L->[i-increment]) { L->r[0]=L->r[i]; for(j=i-increment;j>0&&L->r[0]<L->r[j];j-=increment) L->r[j+increment]=L->r[j]; //记录后移，查找插入位置 L->r[j+increment]=L->r[0]; //插入 } } }} L'arrangement de bulles est un échange d'agencement, son idée de base est la suivante: deux mots-clés d'enregistrements adjacents, si la chaîne est une échange en arrière jusqu'à ce qu'il n'y ait pas d'enregistrement.

Étapes à suivre comme suit:

Du premier bit, deux deux deux deux comparent des valeurs adjacentes, si les deux valeurs descendantes, échangeant la position de la position de la position jusqu'à ce que La dernière fois, la finale est donc définitivement la plus grande valeur
car le bit est enfin la valeur maximale, les autres valeurs ont été répétées en dehors de la dernière partie, d'autres valeurs seront répétées .
Répétez les deux étapes jusqu'à ce que toutes les valeurs soient triées par

(1) Déploiement de l'ordre de bulle La plus version

Chaque valeur de la séquence est parcouru, puis la valeur est dans la chaîne arrière. Chaque valeur est comparée, si elle est supérieure aux échanges de l'autre.

Cet algorithme est complètement non bubble, car il n'est pas satisfaitDeux ou deux autres personnes de plus, tapez l'idée de bulles par rapport aux enregistrements adjacents.

(2) Commandes à bulles normales

Le processus officiel de l'arrangement de bulle basé sur les étapes de base des bulles disposées devant nous. Le code est le suivant:

void BubbleSort0(SqList *L){ int i,j; for(i=1;i<L-length;i++) { for(j=i+1;j<L-length;j++) { if(L->r[i] > L->r[j]) { swap(L,i,j) } } }} Le code ci-dessus indique que la comparaison de la transmission précédente de l'extrémité de la chaîne, première comparable au second bit de l'avant-dernier et le bit précédent, la valeur II utilise le contrôle numérique numérique de la valeur ne participe pas à une comparaison (c.-à-d. Le nombre de bits a une valeur maximale), la valeur que j'ai démarrée est 1, affichant toutes les valeurs numériques liées à des points inverse, lorsque la comparaison est terminée. (c'est-à-dire que la boucle de J est terminée une fois) ma valeur est ajoutée 1 et la réduction du numéro de comparaison est 1, répétez ce processus jusqu'à ce que tout le traitement des prix a été organisé (c'est-à-dire la valeur de I supérieure ou égale à la longueur de la chaîne être disposé).


(3) Version améliorée de l'ordre à bulles

en PType de bulle normale, seule la dernière personne ne participe pas à l'arrangement, à l'exception de la dernière fois qu'une séquence doit toujours participer à la classification, que les commandes soient commandées, les chaînes autres que le premier endroit ont ou partie, alors peut-il être commandé plus? La réponse est définitivement, il suffit d'ajouter un signe pour déterminer quelle partie de la chaîne est la séquence.

2. Agencement rapide void BubbleSort(SqList *L){ int i,j; for(i=1;i<L-length;i++) { for(j=L-length-1;j>=i;j--) { if(L->r[j] > L->r[j+1]) //注意这里是比较j与j+1 { swap(L,j,j+1); //交换L->r[j]与L->r[j+1]的位置 } } }}

est enfin apparu dans la ligne rapide légendaire, la règle rapide consiste à organiser rapidement, organiser en fonction du changement d'attribution. L'un d'eux. Disposez rapidement lorsque vous commencez à trier, vous choisirez d'abord une valeur intermédiaire M (Notez que la valeur intermédiaire ici n'est pas la valeur moyenne), en utilisant généralement le premier numéro de la colonne pour trier, chaque séquence sera commandée à chaque fois. Divisé en deux parties, tous sont supérieurs à la valeur moyenne m, tandis que toutes les valeurs de l'autre sont plus petites que la valeur intermédiaire m, puis créent du poissonC Les marchandises rapides de ces deux parties et trouvent simultanément une valeur intermédiaire M, puis effectuez un intervalle de temps, répétez cette procédure jusqu'à la fin de toutes les chaînes et de recevoir enfin une chaîne est commandée et le code est comme suit:

IV. Choisissez le type de classe

void BubbleSort2(SqList *L){ int i,j; Status flag = True; //flag用来标记哪部分是已排序好的 for(i=1,i<L-length&&flag;i++) { flag = False; for(j=L->length-1;j>=i;j--) { if(L->r[j] > L->r[j+1]) { swap(L[j],L[j+1]) flag = True } } }} 1. Sélectionnez simplement la commande



L'arrangement à bulles est échangée lors de la comparaison pendant la commutation, l'exemption est inférieure à la valeur, le La valeur frontale est échangée, alors continue de comparer; Et la séquence est simplement le numéro de comparaison d'un certain nombre de positions avec la position, si le nombre de la chaîne est inférieur au nombre de positions, puis transférez la position de deux, sinon, entrez la boucle suivante, cette méthode est une peu similaire au type de bulle de base. Il suffit de sélectionner le tri comparable à l'arrangement à bulles, de nombreux échanges sont ignorés. Le code est le suivant:
void QuickSort(int R[],int low,int high){ int temp; int i = low;j = high; if(low < high) { temp = R[low];//序列的第一个值作为中间值 while(i<j) { while(j>i&&R[j]>=temp)//从右往左寻找小于temp的值 --j; if(i<j) { R[i]=R[j];//放在temp左边 ++i;//i后移一位 } while(i<j&&R[i]<temp)//从左往右寻找大于temp的值 ++i; if(i<j) { R[j]=R[i];//放在temp右边 --j;//左移一位 } } } R[i] = temp;//将temp挡在最终位置 QuickSort(R,low,i-1);//对temp左边的值再执行快排 QuickSort(R,i+1,high);//对temp右边的值再执行快排}

dans la sélection simple avant, sélectionnez MJe suis dans n records pour trier le plus petit enregistrement nécessite la comparaison N-1, continuez de comparer N-2 fois dans l'enregistrement N-1 restant pour avoir un deuxième minimum. Chaque fois que vous devez comparer le reste de la valeur, vous choisirez au minimum le reste. Cependant, certaines valeurs ont été contrastées, n'ont pas besoin de comparer à nouveau. Si vous pouvez ajuster une valeur comparative, vous pouvez éviter de nombreuses comparaisons inutiles. Pile d'habitudes spéciales Pour résoudre ce problème, les habitudes d'empilement sont une version simple de la version améliorée.




Le tas est un arbre binaire complet avec les attributs suivants: la valeur de chaque bouton est plus grande ou égale au bouton enfant gauche et droit, appelé Top 2 grandes; Ou la valeur de chaque bouton est inférieure ou égale à la valeur des enfants gauche et droit, appelé une petite tête. void SelectSort(SqList *L){ int i,j,min; for(i=1;i<L->length;i++) { min = i; for(j = i+1;j<=L->length;j++) { if(L->r[min] > L->r[j]) //如果存在i后面的值比i值小 //则把该值传给参数min min = j; } if(i != min) //如果最小值不是i，则交换i和min的位置 swap(L,i,min); }}
La mise en œuvre de la classification des tas

La pile est la méthode de disposition à l'aide de tas. Son idée de base est de former un quizLe grand sommet de la séquence sera disposé. De cette manière, la valeur maximale de la chaîne entière est le bouton d'origine du haut. Retrait du bouton d'origine, le bouton d'origine est optimisé, puis récupéré les chaînes N-1 restantes dans un tas, le bouton d'origine de la nouvelle pile est la valeur maximale de la nouvelle pile et de la valeur secondaire dans l'élément N Ceci. Ceci est répété, une commande de commande peut être prise.
Donc, Type Heap est vraiment deux étapes. La première étape consiste à convertir les données triées en une grande pile. La deuxième étape consiste à éliminer progressivement les boutons d'origine de chaque valeur maximale. Et encore une fois ajusté à une grande grande pile. Le code est le suivant:
5. Multiplexing Multi-ordre est la division d'algorithme, retourne au tri de nombreuses façons de retourner, Nous expliquons les deux manières les plus simples: d'abord diviser la ficelle entière en deux moitiés et sont disposées à chaque demi, de sorte que les deux séquences que la commande soit obtenue puis que deux processus soient intégrés à une chaîne. CodeLa mise en œuvre régulière est la suivante: