Algorithme de tri - Tri par tas

Heapsort (anglais : Heapsort) fait référence à un algorithme de tri conçu à l'aide de la structure de données du tas. Le tas est une structure qui se rapproche d'un arbre binaire complet, et en même temps satisfait la nature du tas : c'est-à-dire que la valeur de clé ou l'index d'un nœud enfant est toujours plus petit (ou plus grand) que son nœud parent.

Dans la structure de données du tas, la valeur maximale dans le tas est toujours située au nœud racine (si le tas est utilisé dans la file d'attente prioritaire, la valeur minimale dans le tas est située au nœud racine). Les opérations suivantes sont définies dans le tas :
Max Heapify : ajuste les nœuds enfants finaux du tas afin que les nœuds enfants soient toujours plus petits que le nœud parent
Build Max Heap : réorganise toutes les données dans le
tas Tri (HeapSort) : supprime le bit au nœud racine des premières données, et faire l'opération récursive de l'ajustement de tas maximum

—Ce qui précède provient de l'encyclopédie Baidu

Parmi eux, le grand tas supérieur et le petit tas supérieur correspondent à l'ordre croissant et décroissant de l'algorithme.
Ce code prend l'ordre croissant du gros tas comme exemple :

Fonction du programme :
void swap(int *a,int *b)
void heapify(int *a,int len,int i)//Maintenance du tas, changer la valeur du nœud parent i au nombre maximum du tas.
void heapsort(int *a,int len)//entrée de tri de tas

Connaissances de base : (pour des connaissances spécifiques, veuillez vous référer à la structure de données - tas, arbre binaire)
chaque nœud parent avec l'indice i : (i-1)/2 ;
chaque nœud enfant gauche avec l'indice i : 2 i+1
chaque nœud enfant droit avec indice i : 2 i+2

Code complet :

#include<stdio.h>

void swap(int *a,int *b)
{
    
    
	int temp;
	temp=*a;
	*a=*b;
	*b=temp;
}
void heapify(int *a,int len,int i)//堆的维护，把父节点i的数值变成此堆最大的数。
{
    
    
	int largest=i,lson=i*2+1,rson=i*2+2;
	if(lson<len && a[largest]<a[lson])largest=lson;
	if(rson<len && a[largest]<a[rson])largest=rson;
	if(largest!=i)
	{
    
    
		swap(&a[i],&a[largest]);
		heapify(a,len,largest);
	}
}
/*
基本知识：
每个下标为i的父节点：(i-1)/2;
每个下标为i的左孩子节点：2*i+1
每个下标为i的右孩子节点：2*i+2
*/

void heapsort(int *a,int len)//堆排序入口
{
    
    
	int i;
	for(i=(len/2-1);i>=0;i--)//从最后一个父节点开始维护,建堆
	{
    
    
		heapify(a,len,i);
	}

	for(i=len-1;i>0;i--)//把最后的数和堆顶值交换，然后再进行堆的维护
	{
    
    
		swap(&a[0],&a[i]);//把堆顶最大的数和堆尾的数交换
		heapify(a,i,0);//对堆顶进行维护，最大的数始终要在堆顶
	}
}

int main()
{
    
    
	int i;
	int a[]={
    
    3,5,1,-7,4,9,-6,8,10,4};
	int len=(int)sizeof(a)/sizeof(int);
	heapsort(a,len);
	for(i=0;i<len;i++)printf("%3d",a[i]);
	printf("\n");
	return 0;
}