petit soucis d aleatoir

**joe0703** · 30/11/2017, 12h39

bonjour,
comme dit dans le titre j ai un petit soucis avec un rand

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
int * RandomArray(int n)
{
    srand(time(NULL));
    int tab[n];
    int i=0;
    while (i<n)
    {
      tab[i]=(rand()%n);
      i++;
    }
  return tab;
}

via ce code je cree un tableau de n valeur remplis de valeur aléatoire entre 0 et n
le soucis est que quand j'affiche mon tableau les valeurs sont supérieur a n
ce que je ne comprend pas vu que j ai écrit

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(rand()%n)

si quelqu un pouvais me renseigner je lui en serais grès merci

**Bousk** · 30/11/2017, 12h48

Es-tu vraiment en C++ ? Parce que ce code a tout d'un code C et int tab[n]; est un VLA qui n'est pas du tout permis en C++ et à peine dans certaines normes C.
Sans compter le retour d'une variable interne et donc temporaire.

**joe0703** · 30/11/2017, 13h08

heuuu oui je suis en C++ vu que c'est moi qui est crée le code ^^"
VLA ? (explique )

et si je fait un int x = 4 ;
je peut bien faire un tab[x] ; meme en c++
non ? car j ai jamais eu de soucis la dessus moi ^^"
ensuite c est une fonction or si je ne m abuse tt les retour des fonction sont temporaire ..... vu qu'il ne sont propre qu au moment et au valeur fournis a l appel de la fonction dans le main
le mien etant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
    int n=0;
    while (n<=5 || n>=500000 )
    {
        cout<<"entrer une valeur entre 5 et  500000 : "<<endl;
        cin >>n;
    }
    int *arrays = RandomArray(n);
    affiche (arrays, n);

**ternel** · 30/11/2017, 14h19

VLA pour Variable Length Array: tableau à taille variable (par opposé à une taille connue à la compilation).
Ce n'est pas standard.

Il est probable que tu compiles avec des extensions au langage, que tu devrais désactiver autant que possible.
Avec gcc, recoure à --std=c++14 (ou variante comme c++17, c++1y, c++1z, voire c++2a)

De plus, tu devrais activer un maximum de warning de compilation.

Ta fonction retourne l'adresse d'un tableau qui est une variable locale.

À la fin de la fonction, ce tableau est rendu à la mémoire, et l'adresse retournée n'est plus utilisable. On parle de "dangling reference".
La prochaine variable locale déclarée se trouvera probablement au même endroit.

Ce qui est temporaire, c'est la valeur retournée. Pour les pointeurs et les références, cela pose problème, car ce qui est désigné n'existe plus.

Utilise un std::vector, et tout ira mieux.
De même, tu pourrais (et devrais) utiliser les fonctions d'aléatoire moderne, qui ont moins de défauts que rand et srand.

Typiquement, tu pourrais utiliser

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <vector>
#include <random>
 
std::vector<int> RandomArray(std::mt19937 & gen, std::vector<int>::size_type n, int min, int max) {
    std::uniform_int_distribution<> dis(min, max);
 
    std::vector<int> valeurs;
    valeurs.reserve(n);
    while (valeurs.size() < n) valeurs.push_back( dis(gen) );
    return valeurs;
}
 
int main() {
    std::random_device rd;  //Will be used to obtain a seed for the random number engine
    std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
 
    int n = 0;
    while (n<=5 || n>=500000 ) {
        cout<<"entrer une valeur entre 5 et  500000 : "<<endl;
        cin >>n;
    }
    auto array = RandomArray(gen, n, 0, 1000); //pour générer des nombres entre 0 et 1000.
    affiche (array, n);
}

Idéalement, tu pourrais rendre la fonction template pour qu'elle accepte n'importe quel type de générateur.

**joe0703** · 30/11/2017, 15h27

je n'est malheureusement pas le choix car il s'agit d un sujet de fac

2.1 Creation aletoire de tableaux
Ecrire une fonction
int ∗ RandomArray(int n)
renvoyant un tableau de n entiers dont les ´elements sont choisis aleatoirement
entre 0 et n.
Indication : vous vous aiderez de la fonction predefinie C + +, rand()

**Médinoc** · 30/11/2017, 15h37

Dans ce cas pas le choix, il faudra que tu utilises new[].
La consigne ne te laisse même pas le choix de retourner un pointeur intelligent...

**joe0703** · 30/11/2017, 15h41

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
int * RandomArray(int n)
{
    srand(time(NULL));
   int *tab=new int [n];
 
    for (int i=0;i<n;i++)
    {
      tab[i]=(rand()%n);
    }
  return tab;
 
}

a priori cela a l'air de fonctionner merci
par contre il faut que je place n delete quelque part non ?

également cela me pose un autre soucis car ce sujet de tp porte sur les différents type de tri ( bulle , insertion , fusion , rapide )

or avant d'utiliser des tableau aléatoire mes tri fonctionner mais désormais mon tri fusion ne fonctionne plus ..... je comprend pas pourquoi vu qu il n'y a pas de reel différence avec un tableau crée via fonction et un tableau initialiser a la mains

voici mon code total ce coup ci si vous avez une idee d'ou peu venir le soucis

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <cstdio>
 
using namespace std;
 
void fusion (int *a, int n, int m)
{
    int i, j, k;
 
   int * x = new int [n];
    for (i = 0, j = m, k = 0; k < n; k++) {
        x[k] = j == n      ? a[i++]
             : i == m      ? a[j++]
             : a[j] < a[i] ? a[j++]
             :               a[i++];
    }
    for (i = 0; i < n; i++) {
        a[i] = x[i];
    }
    delete(x);
}
 
void tri_fusion (int *liste, int taille) {
    if (taille < 2) return;
    int milieu = taille / 2;
    tri_fusion(liste, milieu);
    tri_fusion(liste- milieu, taille - milieu);
    fusion(liste, taille, milieu);
}
void tri_bulle(int* tableau,int x)
{
    int passage = 0;
    bool permutation = true;
    int en_cours;
 
    while ( permutation) {
        permutation = false;
        passage ++;
        for (en_cours=0;en_cours<x-passage;en_cours++) {
            if (tableau[en_cours]>tableau[en_cours+1]){
                permutation = true;
                // on echange les deux elements
                int temp = tableau[en_cours];
                tableau[en_cours] = tableau[en_cours+1];
                tableau[en_cours+1] = temp;
            }
        }
    }
}
void tri_insertion(int* t,int x)
{
    int i, j;
    int en_cours;
 
    for (i = 1; i < x; i++) {
        en_cours = t[i];
        for (j = i; j > 0 && t[j - 1] > en_cours; j--) {
            t[j] = t[j - 1];
        }
        t[j] = en_cours;
    }
}
void tri_rapide (int *tableau, int taille) {
    int mur, courant, pivot, tmp;
    if (taille < 2) return;
    // On prend comme pivot l element le plus a droite
    pivot = tableau[taille - 1];
    mur  = courant = 0;
    while (courant<taille) {
        if (tableau[courant] <= pivot) {
            if (mur != courant) {
                tmp=tableau[courant];
                tableau[courant]=tableau[mur];
                tableau[mur]=tmp;
            }
            mur ++;
        }
        courant ++;
    }
    tri_rapide(tableau, mur - 1);
    tri_rapide(tableau + mur - 1, taille - mur + 1);
}
void affiche(int* tableau,int x)
{
    for (int i=0;i<x;i++)
    {
        cout<<" "<<tableau[i]<<" ";
    }
    cout<<endl;
    cout<<endl;
}
int * RandomArray(int n)
{
    srand(time(NULL));
   int *tab=new int [n];
 
    for (int i=0;i<n;i++)
    {
      tab[i]=(rand()%n);
    }
  return tab;
 
}
 
int main()
{
    int n=0;
    while (n<=5 || n>=500000 )
    {
        cout<<"entrer une valeur entre 5 et  500000 : "<<endl;
        cin >>n;
    }
    int *arrays = RandomArray(n);
    affiche (arrays, n);
    cout<<"tri bulle"<<endl;
    tri_bulle(arrays, n);
    affiche (arrays, n);
    int *arrays1 = RandomArray(n);
    affiche (arrays1, n);
    cout<<"tri insertion"<<endl;
    tri_insertion(arrays1, n);
    affiche (arrays1, n);
    int *arrays2 = RandomArray(n);
    affiche (arrays2, n);
    cout<<"tri rapide"<<endl;
   // tri_rapide(arrays2, n);
    affiche (arrays2, n);
    int *arrays3 = RandomArray(n);
    affiche (arrays3, n);
    cout<<"tri fusion"<<endl;
     tri_fusion(arrays3, n);
   // affiche (arrays3, n);
 
}

**ternel** · 30/11/2017, 16h27

A ceci près que tu nes dois pas appeler srand à chaque appel de la fonction.
Sauf une très bonne raison, on ne devrait l'appeler qu'une seule fois dans le programme.

**Médinoc** · 30/11/2017, 16h40

Envoyé par joe0703

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
int * RandomArray(int n)
{
	srand(time(NULL));
	int *tab=new int [n];
	for (int i=0;i<n;i++)
	{
		tab[i]=(rand()%n);
	}
	return tab;
}

a priori cela a l'air de fonctionner merci
par contre il faut que je place n delete quelque part non ?

Oui, il te faut un delete[] dans le code qui appelle la fonction RandomArray().
De plus, ce n'est pas le bon endroit pour ton appel à srand(): Tu n'est censé appeler la fonction qu'au début de ton programme, et non pour chaque tableau (autrement, si tu crées deux tableaux dans la même seconde, ils seront identiques).

également cela me pose un autre soucis car ce sujet de tp porte sur les différents type de tri ( bulle , insertion , fusion , rapide )

or avant d'utiliser des tableaux aléatoires mes tris fonctionnaient mais désormais mon tri fusion ne fonctionne plus ..... je comprend pas pourquoi vu qu il n'y a pas de réelle différence avec un tableau crée via fonction et un tableau initialisé a la mains

voici mon code total ce coup-ci si vous avez une idée d'où peu venir le soucis

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <cstdio>
 
using namespace std;
 
void fusion (int *a, int n, int m)
{
    int i, j, k;
 
   int * x = new int [n];
    for (i = 0, j = m, k = 0; k < n; k++) {
        x[k] = j == n      ? a[i++]
             : i == m      ? a[j++]
             : a[j] < a[i] ? a[j++]
             :               a[i++];
    }
    for (i = 0; i < n; i++) {
        a[i] = x[i];
    }
    delete(x);
}

Sérieusement, un opérateur ternaire triple? Tu codes pour ta fac ou pour l'IOCCC? Surtout avec des noms de variable d'une lettre...
De plus, pour un tableau, il faut utiliser delete[], au lieu d'un delete simple.
(pour les problèmes de perf liés à allouer un nouveau tableau à chaque fusion, on verra plus tard... beaucoup plus tard)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
void tri_fusion (int *liste, int taille) {
    if (taille < 2) return;
    int milieu = taille / 2;
    tri_fusion(liste, milieu);
    tri_fusion(liste- milieu, taille - milieu);
    fusion(liste, taille, milieu);
}

Problème ici: Le second appel à tri_fusion() doit utiliser liste+milieu.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
void tri_bulle(int* tableau,int x)
{
    int passage = 0;
    bool permutation = true;
    int en_cours;
 
    while ( permutation) {
        permutation = false;
        passage ++;
        for (en_cours=0;en_cours<x-passage;en_cours++) {
            if (tableau[en_cours]>tableau[en_cours+1]){
                permutation = true;
                // on echange les deux elements
                int temp = tableau[en_cours];
                tableau[en_cours] = tableau[en_cours+1];
                tableau[en_cours+1] = temp;
            }
        }
    }
}
void tri_insertion(int* t,int x)
{
    int i, j;
    int en_cours;
 
    for (i = 1; i < x; i++) {
        en_cours = t[i];
        for (j = i; j > 0 && t[j - 1] > en_cours; j--) {
            t[j] = t[j - 1];
        }
        t[j] = en_cours;
    }
}
void tri_rapide (int *tableau, int taille) {
    int mur, courant, pivot, tmp;
    if (taille < 2) return;
    // On prend comme pivot l element le plus a droite
    pivot = tableau[taille - 1];
    mur  = courant = 0;
    while (courant<taille) {
        if (tableau[courant] <= pivot) {
            if (mur != courant) {
                tmp=tableau[courant];
                tableau[courant]=tableau[mur];
                tableau[mur]=tmp;
            }
            mur ++;
        }
        courant ++;
    }
    tri_rapide(tableau, mur - 1);
    tri_rapide(tableau + mur - 1, taille - mur + 1);
}
void affiche(int* tableau,int x)
{
    for (int i=0;i<x;i++)
    {
        cout<<" "<<tableau[i]<<" ";
    }
    cout<<endl;
    cout<<endl;
}
int * RandomArray(int n)
{
    srand(time(NULL));
   int *tab=new int [n];
 
    for (int i=0;i<n;i++)
    {
      tab[i]=(rand()%n);
    }
  return tab;
 
}
 
int main()
{
    int n=0;
    while (n<=5 || n>=500000 )
    {
        cout<<"entrer une valeur entre 5 et  500000 : "<<endl;
        cin >>n;
    }
    int *arrays = RandomArray(n);
    affiche (arrays, n);
    cout<<"tri bulle"<<endl;
    tri_bulle(arrays, n);
    affiche (arrays, n);
    int *arrays1 = RandomArray(n);
    affiche (arrays1, n);
    cout<<"tri insertion"<<endl;
    tri_insertion(arrays1, n);
    affiche (arrays1, n);
    int *arrays2 = RandomArray(n);
    affiche (arrays2, n);
    cout<<"tri rapide"<<endl;
   // tri_rapide(arrays2, n);
    affiche (arrays2, n);
    int *arrays3 = RandomArray(n);
    affiche (arrays3, n);
    cout<<"tri fusion"<<endl;
     tri_fusion(arrays3, n);
   // affiche (arrays3, n);
 
}

Il manque le delete[] après l'affichage de chaque tableau. Ou alors, tu peux utiliser des std::unique_ptr<int[]> à la place des int*.
De plus, je suis surpris que tu n'aies pas un tri par sélection dans le lot, alors que ton tri par insertion "sur place" me paraît redondant avec le tri à bulle...

**joe0703** · 30/11/2017, 17h20

j'ai modifier mon code en fonction de vos remarque
la seule que je n'est pas forcement comprise est celle de medinoc

Il manque le delete[] après l'affichage de chaque tableau. Ou alors, tu peux utiliser des std::unique_ptr<int[]> à la place des int*.

je ne vois pas où mettre les delete en question

pour ta remarque non je n'est pas de demande de tri par selection dans mon sujet de tp

Tris `a coder
Ecrire les fonctions de tri :
– TriBulle : correspondant au tri bulle,
– TriInsertion : correspondant au tri par insertion,
– TriFusion : correspondant au tri fusion,
– TriRapide : correspondant au tri rapide,
– TriTas : correspondant au tri par tas.

et oui oui mdr c'est bien pour la fac mdr :p je ne fait pas encore de concours C++ ptdr ^^

bon par contre le code fonctionne désormais le soucis venais du liste - milieu

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <cstdio>
 
using namespace std;
 
void fusion (int *a, int n, int m)
{
    int i, j, k;
 
   int * x = new int [n];
    for (i = 0, j = m, k = 0; k < n; k++) {
        x[k] = j == n      ? a[i++]
             : i == m      ? a[j++]
             : a[j] <  a[i] ||  a[j] ==  a[i]? a[j++]
             :               a[i++];
 
    }
    for (i = 0; i < n; i++) {
        a[i] = x[i];
    }
    delete []x;
}
 
void tri_fusion (int *liste, int taille) {
    if (taille < 2) return;
    int milieu = taille / 2;
    tri_fusion(liste, milieu);
    tri_fusion(liste+ milieu, taille - milieu);
    fusion(liste, taille, milieu);
}
void tri_bulle(int* tableau,int x)
{
    int passage = 0;
    bool permutation = true;
    int en_cours;
 
    while ( permutation) {
        permutation = false;
        passage ++;
        for (en_cours=0;en_cours<x-passage;en_cours++) {
            if (tableau[en_cours]>tableau[en_cours+1]){
                permutation = true;
                // on echange les deux elements
                int temp = tableau[en_cours];
                tableau[en_cours] = tableau[en_cours+1];
                tableau[en_cours+1] = temp;
            }
        }
    }
}
void tri_insertion(int* t,int x)
{
    int i, j;
    int en_cours;
 
    for (i = 1; i < x; i++) {
        en_cours = t[i];
        for (j = i; j > 0 && t[j - 1] > en_cours; j--) {
            t[j] = t[j - 1];
        }
        t[j] = en_cours;
    }
}
void tri_rapide (int *tableau, int taille) {
    int mur, courant, pivot, tmp;
    if (taille < 2) return;
    // On prend comme pivot l element le plus a droite
    pivot = tableau[taille - 1];
    mur  = courant = 0;
    while (courant<taille) {
        if (tableau[courant] <= pivot) {
            if (mur != courant) {
                tmp=tableau[courant];
                tableau[courant]=tableau[mur];
                tableau[mur]=tmp;
            }
            mur ++;
        }
        courant ++;
    }
    tri_rapide(tableau, mur - 1);
    tri_rapide(tableau + mur - 1, taille - mur + 1);
}
void affiche(int* tableau,int x)
{
    for (int i=0;i<x;i++)
    {
        cout<<" "<<tableau[i]<<" ";
    }
    cout<<endl;
    cout<<endl;
}
int * RandomArray(int n)
{
 
   int *tab=new int [n];
 
    for (int i=0;i<n;i++)
    {
      tab[i]=(rand()%n);
    }
  return tab;
delete []tab;
}
 
int main()
{
    srand(time(NULL));
    int n=0;
    while (n<=5 || n>=500000 )
    {
        cout<<"entrer une valeur entre 5 et  500000 : "<<endl;
        cin >>n;
    }
    cout<<endl;
    int *arrays = RandomArray(n);
    affiche (arrays, n);
    cout<<"tri bulle"<<endl;
    tri_bulle(arrays, n);
    affiche (arrays, n);
    int *arraysUN = RandomArray(n);
    affiche (arraysUN, n);
    cout<<"tri insertion"<<endl;
    tri_insertion(arraysUN, n);
    affiche (arraysUN, n);
    int *arraysDEUX = RandomArray(n);
    affiche (arraysDEUX, n);
    cout<<"tri rapide"<<endl;
    tri_rapide(arraysDEUX, n);
    affiche (arraysDEUX, n);
    int *arraysTROIS = RandomArray(n);
    affiche (arraysTROIS, n);
    cout<<"tri fusion"<<endl;
     tri_fusion(arraysTROIS, n);
    affiche (arraysTROIS, n);
 
}

**Médinoc** · 01/12/2017, 11h54

Les delete[] sont à rajouter à ces endroits-là:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
int main()
{
	srand(time(NULL));
	int n=0;
	while (n<=5 || n>=500000 )
	{
		cout<<"entrer une valeur entre 5 et  500000 : "<<endl;
		cin >>n;
	}
	cout<<endl;
	//J'ajoute des blocs pour la clarté
	{
		int *arrays = RandomArray(n);
		affiche (arrays, n);
		cout<<"tri bulle"<<endl;
		tri_bulle(arrays, n);
		affiche (arrays, n);
		delete[] arrays;
	}
	{
		int *arraysUN = RandomArray(n);
		affiche (arraysUN, n);
		cout<<"tri insertion"<<endl;
		tri_insertion(arraysUN, n);
		affiche (arraysUN, n);
		delete[] arraysUN;
	}
	{
		int *arraysDEUX = RandomArray(n);
		affiche (arraysDEUX, n);
		cout<<"tri rapide"<<endl;
		tri_rapide(arraysDEUX, n);
		affiche (arraysDEUX, n);
		delete[] arraysDEUX;
	}
	{
		int *arraysTROIS = RandomArray(n);
		affiche (arraysTROIS, n);
		cout<<"tri fusion"<<endl;
		tri_fusion(arraysTROIS, n);
		affiche (arraysTROIS, n);
		delete[] arraysTROIS;
	}
	return 0;
}

Ou encore:

Code C++11 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
#include <memory>
 
int main()
{
	srand(time(NULL));
	int n=0;
	while (n<=5 || n>=500000 )
	{
		cout<<"entrer une valeur entre 5 et  500000 : "<<endl;
		cin >>n;
	}
	cout<<endl;
	//J'ajoute des blocs pour la clarté
	{
		std::unique_ptr<int[]> arrays(RandomArray(n));
		affiche (arrays, n);
		cout<<"tri bulle"<<endl;
		tri_bulle(arrays, n);
		affiche (arrays, n);
	}
	{
		std::unique_ptr<int[]> arraysUN(RandomArray(n));
		affiche (arraysUN, n);
		cout<<"tri insertion"<<endl;
		tri_insertion(arraysUN, n);
		affiche (arraysUN, n);
	}
	{
		std::unique_ptr<int[]> arraysDEUX(RandomArray(n));
		affiche (arraysDEUX, n);
		cout<<"tri rapide"<<endl;
		tri_rapide(arraysDEUX, n);
		affiche (arraysDEUX, n);
	}
	{
		std::unique_ptr<int[]> arraysTROIS(RandomArray(n));
		affiche (arraysTROIS, n);
		cout<<"tri fusion"<<endl;
		tri_fusion(arraysTROIS, n);
		affiche (arraysTROIS, n);
	}
}

Ou encore:

Code C++11 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <memory>
 
void TestTri(const char *nom, void (*fonctionTri)(int*, int), int taille)
{
	std::unique_ptr<int[]> tableau(RandomArray(taille));
	affiche(tableau, taille);
	cout << nom << endl;
	fonctionTri(tableau, taille);
	affiche(tableau, taille);
}
 
int main()
{
	srand(time(NULL));
	int n=0;
	while (n<=5 || n>=500000 )
	{
		cout<<"entrer une valeur entre 5 et  500000 : "<<endl;
		cin >>n;
	}
	cout<<endl;
 
	TestTri("tri bulle", tri_bulle, n);
	TestTri("tri insertion", tri_insertion, n);
	TestTri("tri rapide", tri_rapide, n);
	TestTri("tri fusion", tri_fusion, n);
}

petit soucis d aleatoir

C++

Discussions similaires

Partager

Partager