tri par sélection simple

#include<iostream>
using namespace std;

#define MAXSIZE 20  //记录最大个数
typedef int KeyType;  //关键字类型

typedef int InfoType;

//定义每个记录（数据元素）的结构
struct RecType
    //Record Type：每条记录的类型
{
    KeyType key;  //关键字
    InfoType otherinfo;  //其他数据项
};

struct SqList
    //顺序表(的)结构
{
    RecType r[MAXSIZE + 1];
    //类型为【记录类型】的数组
    //r[0]一般做哨兵或缓冲区
    int length;  //顺序表长度
};

void SelectSort(SqList& L)
{
    for (int i = 1; i <= L.length; i++)
    {
        int k = L.r[i].key;
        for (int j = i; j <= L.length; j++)
        {
            if (L.r[j].key < k)
                k = L.r[j].key;
        }
        if (k != L.r[i].key)
        {
            int temp = L.r[i].key;
            L.r[i].key = k;
            k = temp;
        }
    }
}


int main()
{

}

tri en tas

Ajustements de tas :

Dagendu

void HeapAdjust(Elem R[], int s, int m) //Heap：堆
//二叉树空间范围：s-m，这里写的是大根堆
// s：smallest
// m：max
{
    //调整R[s]的关键字，使R[s...m]重新成为一个大根堆
    Elem rc = R[s];
    for (int j = 2 * s; j <= m; j *= 2)
    {
        if (j < m && R[j] < R[j + 1])
            j++;  //j为关键字较大的数据元素下标
        if (rc >= R[j])
            break;
        R[s] = R[j];
        s = j;  //记录位置
    }
    R[s] = rc;  //插入
}

Au tout début (au tout début), on a regardé ce programme, c'était complètement incompréhensible, wow

On s'est même posé la question : comment a-t-il trouvé le dernier élément ici ? ? ? Pourquoi je ne l'ai pas vu ?

Alors créons/trouvons d'abord un moyen de faire un petit tas de racines selon la peinture de calebasse :

petit tas de racines

void HeapAdjust(Elem R[], int s, int m) //小根堆
{
    Elem rc = R[s];
    for (int j = 2 * s; j <= m; j *= 2)
    {
        if (j < m && R[j] > R[j + 1])
            j++;  //j为关键字较小的数据元素下标
        if (rc <= R[j])
            break;
        R[s] = R[j];
        s = j;  //记录位置
    }
    R[s] = rc;  //插入
}

Ensuite, nous nous sommes prosternés silencieusement devant le programme pendant un long moment, et avons finalement compris dans quoi il était écrit :

Le processus complet de l'ajustement du tas entier est le suivant :

Et ici (en fait nous y sommes):

PPT écrit en fait l'algorithme de l'ensemble du processus de l'étape 2 (Figure 2) à l'étape 4 (Figure 4)

Au lieu de tmd, l'algorithme pour l'ensemble du processus à partir de la figure 1

Au début du programme, il a déjà terminé les opérations de processus précédentes de la figure 1 à la figure 2 par défaut, et a organisé les opérations pour nous à l'avance.

TMD !

Annotez le programme en fonction de l'opération : (Après avoir lu l'annotation, vous saurez comment le programme fonctionne à chaque étape)

Prenons l'exemple du petit tas de racines : (Il en va de même pour le gros tas de racines, donc je ne le répéterai pas ici)

void HeapAdjust(Elem R[], int s, int m) //小根堆
{
    Elem rc = R[s];
    //此时最后的元素已经被放到堆顶，rc记录最后一位元素
    for (int j = 2 * s; j <= m; j *= 2)
        //从第二层子树开始遍历
    {
        if (j < m && R[j] > R[j + 1])
            j++; 
        //j：关键字较小的元素下标
        if (rc <= R[j])
            break;
        //要最后一个元素比他小就算了，不然的话：
        R[s] = R[j];
        //j（较小）元素放上面去
        s = j;  
        //下一轮for循环：
        //从上一轮j的位置开始往下遍历
        //以j的位置为根，向下遍历子树，不断把值小的元素移上去
    }
    R[s] = rc; 
    //最后，把最后的元素插入到最底部
    // 注：
    // 最后退出循环的时候s已经指向最底层了
    // 而不出意外的话，最后的元素理论上也应该是堆里面最大的一个元素
}

création de tas

#include<iostream>
using namespace std;

typedef int Elem;

void HeapAdjust(Elem R[], int s, int m) //小根堆
{
    Elem rc = R[s];
    //此时最后的元素已经被放到堆顶，rc记录最后一位元素
    for (int j = 2 * s; j <= m; j *= 2)
        //从第二层子树开始遍历
    {
        if (j < m && R[j] > R[j + 1])
            j++; 
        //j：关键字较小的元素下标
        if (rc <= R[j])
            break;
        //要最后一个元素比他小就算了，不然的话：
        R[s] = R[j];
        //j（较小）元素放上面去
        s = j;  
        //下一轮for循环：
        //从上一轮j的位置开始往下遍历
        //以j的位置为根，向下遍历子树，不断把值小的元素移上去
    }
    R[s] = rc; 
    //最后，把最后的元素插入到最底部
    // 注：
    // 最后退出循环的时候s已经指向最底层了
    // 而不出意外的话，最后的元素理论上也应该是堆里面最大的一个元素
}

void Swap(int a, int b)
{
    int temp=b;
    b = a;
    a = temp;
}

void HeapSort(Elem R[],int n)
{
    int i;
    for (i = n / 2; i >= 1; i--)  
        HeapAdjust(R, i, n);
    // 我们默认R[]数据无序
    // 先把R[]中的无序数据都排一遍顺序
    // 相当于我们先构造出一个合格的图1

    for (i = n; i > 1; i--)
    {
        cout << R[1] << endl;//逐个输出元素
        Swap(R[1], R[i]);  
        //互换最后一个元素和根
        //相当于执行图1加工到图2的过程

        HeapAdjust(R, 1, i - 1); 
        //面向剩下的元素重新建堆
    }
}

int main()
{

}

question:

Quant à savoir si l'échange du dernier élément et de la racine affectera le résultat du programme, nous n'avons pas à nous en soucier :

Lorsque nous trions le tas de radicelles :

Le dernier élément, c'est-à-dire le plus grand élément, doit être du côté avec une valeur plus grande dans le sous-arbre binaire

Et ce que nous changeons dans le tri de parcours ultérieur est le côté avec la plus petite valeur du sous-arbre binaire, il ne doit donc avoir aucun effet

Il en est de même pour Dagendui, donc je ne le répéterai pas

Principes de base de la structure des données et des algorithmes (Wang Zhuo) (37) : tri par sélection (sélection simple, tri par tas)