Méthode d'impression de tas binaire

Question

Dans ma tâche, je sais que je dois utiliser ma fonction de suppression de tas qui renvoie la variable à imprimer. Mais l'exigence dans la cession est assez vague et j'étais curieux si quelqu'un pouvait me donner une meilleure explication. Je suis assez confus quant à la façon d'utiliser les deuxième ou troisième arguments, je sais qu'un tri est nécessaire et j'ai besoin de deux pour les boucles, mais après cela, je suis perdu. voici ce que l'affectation dit:

template <class T, class P> void print_list (vector<T>&, 
    const int, const int, P); 

Cette fonction récupère des éléments d'une structure de tas et les imprime sur la sortie standard. Pour récupérer un seul élément de la structure de segment, il appelle la fonction de suppression. Le premier argument de cette fonction est un vecteur pour la structure de tas, le deuxième argument est la taille allouée d'un élément imprimé sur stdout, le troisième argument est le nombre maximal d'éléments imprimés sur une seule ligne et le dernier argument est un prédicat .

Voici mon code:

#include "340.h" 

#ifndef H_PROG7 
#define H_PROG7 

// data files 

#define D1 "prog7.d1" 
#define D2 "prog7.d2" 
#define D3 "prog7.d3" 

#define INT_SZ 4 // width of integer 
#define FLT_SZ 7 // width of floating-pt number 
#define STR_SZ 12 // width of string 

#define INT_LN 15 // no of integers on single line 
#define FLT_LN 9 // no of floating-pt nums on single line 
#define STR_LN 5 // no of strings on single line 

// function prototypes 

template<class T,class P> void insert(vector<T>&, const T&, P); 
template<class T,class P> T remove(vector<T>&, P); 

template<class T,class P> void upheap(vector<T>&, int, P); 
template<class T,class P> void downheap(vector<T>&, int, P); 

template<class T,class P> 
void get_list(vector<T>&, const char*, P); 

template<class T,class P> 
void print_list(vector<T>&, const int, const int, P); 

template<class T, class P> 
void get_list(vector<T>& v, const char* file, P func) { 
ifstream inFile("file"); 
T data; 

while(inFile >> data) { 
    inFile >> data; 
    insert(v, data, func); 
} 
} 

template<class T, class P> 
void insert(vector<T>& v, const T& data, P func) { 
v.push_back(data); 
upheap(v, v.size()-1, func); 
} 

template<class T,class P> 
void upheap(vector<T>& v, int start, P func) { 

while(start <= v.size()/2) { 

    unsigned int parent = start/2; 

    if(parent - 1 <= v.size() && v[parent - 1] > v[parent]) 
    parent = parent - 1; 

    if(v[start] <= v[parent]) 
    break; 

    swap(v[start], v[parent]); 
    start = parent; 
} 
} 

template<class T,class P> 
void downheap(vector<T>& v, int start, P func) { 

while(start <= v.size()/2) { 

    unsigned int child = 2 * start; 

    if(child + 1 <= v.size() && v[child + 1] > v[child]) 
    child = child + 1; 

    if(v[start] >= v[child]) 
    break; 

    swap(v[start], v[child]); 
    start = child; 
} 
} 

template<class T,class P> 
T remove(vector<T>& v, P func) { 
swap(v[0], v.back()); 
T& item = v.back(); 

v.pop_back(); 
downheap(v, 1, func); 

return item; 
} 

template<class T,class P> 
void print_list(vector<T>& v, const int size, const int line, P func) { 

for(int i = 1; i < v.size(); i++) { 
    cout << remove(v, func) << " "; 
} 
} 

#endif 

Answer 1

De ce que je comprends, il semble que le 2ème paramètre est le nombre d'espaces un élément dans la liste est autorisé à prendre quand il est imprimé. Le troisième paramètre est le nombre d'éléments autorisés à être imprimés sur une ligne. Dans votre fonction print_list, vous devez suivre le nombre d'éléments que vous avez imprimés pour déterminer si vous devez passer à la ligne suivante ou non en fonction de ce paramètre. En utilisant les deux, vous devriez être capable d'aligner votre sortie correctement. Vous aurez besoin de regarder comment faire le formatage de la sortie.

Par exemple. list = [1, 9, 14, 2000, 244, 777, 3, 98102, 88, 53, 14], la taille = 6, ligne = 3 sortie:

 1  9 14 
    2000 244 777 
    3 98102 88 
    53 14 

Votre dernier paramètre est un prédicat, que vous ne semblez utiliser dans aucune de vos fonctions (un signe que vous faites quelque chose de mal quand vous n'utilisez pas un paramètre du tout). Le paramètre de fonction predicate doit être utilisé pour faire quelque chose qui est unique au type T transmis. Par exemple, dans print_list, il devrait être utilisé pour imprimer une variable de type T. Si vous imprimez un élément comme vous le faites actuellement , il n'y a aucune garantie que le type sera imprimé correctement. Bien sûr, cela fonctionnerait pour les types de base comme int et double, mais imaginez un type avec plusieurs membres différents. Pensez à la façon dont vous auriez besoin d'utiliser ce prédicat dans vos autres fonctions - pouvez-vous simplement comparer les objets avec '<' ou '>'?