Les tableaux en C sharp .Net

 Les tableaux dérivent de la classe Array :
Les tableaux en C sharp .Net
Les tableaux en C sharp .Net
 La classe  Array  possède diverses méthodes pour trier un tableau, rechercher un élément dans un tableau, redimensionner un
tableau, ... Nous présentons certaines propriétés et méthodes de cette classe. Elles sont quasiment toutes surchargées, c.a.d. qu'elles
existent en différentes variantes. Tout tableau en hérite.
Propriétés
public int Length {get;} nombre total d'éléments du tableau, quelque soit son nombre de dimensions
public int Rank {get;} nombre total de dimensions du tableau

Méthodes
public static int BinarySearch<T>(T[] tableau,T
value)
rend la position de value dans tableau.
public static int BinarySearch<T>(T[] tableau,int
index, int length, T value)
idem mais cherche dans tableau à partir de la
position index et sur length éléments
public static void Clear(Array tableau, int index,
int length)
met les length éléments de tableau commençant au n°
index à 0 si numériques, false si booléens, null si
références
public static void Copy(Array source, Array
destination, int length)
copie length éléments de source dans destination
public int GetLength(int i) nombre d'éléments de la dimension n° i du tableau
public int GetLowerBound(int i) indice du 1er élément de la dimension n° i
public int GetUpperBound(int i) indice du dernier élément de la dimension n° i
public static int IndexOf<T>(T[] tableau, T valeur) rend la position de valeur dans tableau ou -1 si
valeur n'est pas trouvée.
public static void Resize<T>(ref T[] tableau, int
n)
redimensionne tableau à n éléments. Les éléments
déjà présents sont conservés.
public static void Sort<T>(T[] tableau,
IComparer<T> comparateur)
trie tableau selon un ordre défini par comparateur.
Cette méthode a été présentée page 81.
Le programme suivant illustre l'utilisation de certaines méthodes de la classe Array :
1. using System;
2.
3. namespace Chap3 {
4. class Program {
5. // type de recherche
6. enum TypeRecherche { linéaire, dichotomique };
7.
8. // méthode principale
9. static void Main(string[] args) {
10. // lecture des éléments d'un tableau tapés au clavier
11. double[] éléments;
12. Saisie(out éléments);
13. // affichage tableau non trié
14. Affiche("Tableau non trié", éléments);
15. // Recherche linéaire dans le tableau non trié
16. Recherche(éléments, TypeRecherche.linéaire);
17. // tri du tableau
18. Array.Sort(éléments);
19. // affichage tableau trié
20. Affiche("Tableau trié", éléments);
21. // Recherche dichotomique dans le tableau trié
22. Recherche(éléments, TypeRecherche.dichotomique);
23. }
24.
25. // saisie des valeurs du tableau éléments
26. // éléments : référence sur tableau créé par la méthode
27. static void Saisie(out double[] éléments) {
28. bool terminé = false;
29. string réponse;
30. bool erreur;
31. double élément = 0;
32. int i = 0;
33. // au départ, le tableau n'existe pas
34. éléments = null;
35. // boucle de saisie des éléments du tableau
36. while (!terminé) {
37. // question
38. Console.Write("Elément (réel) " + i + " du tableau (rien pour terminer) : ");
39. // lecture de la réponse
40. réponse = Console.ReadLine().Trim();
41. // fin de saisie si chaîne vide
42. if (réponse.Equals(""))
43. break;
44. // vérification saisie
45. try {
46. élément = Double.Parse(réponse);
47. erreur = false;
48. } catch {
49. Console.Error.WriteLine("Saisie incorrecte, recommencez");
50. erreur = true;
51. }//try-catch
52. // si pas d'erreur
53. if (!erreur) {
54. // un élément de plus dans le tableau
55. i += 1;
56. // redimensionnement tableau pour accueillir le nouvel élément
57. Array.Resize(ref éléments, i);
58. // insertion nouvel élément
59. éléments[i - 1] = élément;
60. }
61. }//while
62. }
63.
64. // méthode générique pour afficher les éléments d'un tableau
65. static void Affiche<T>(string texte, T[] éléments) {
66. Console.WriteLine(texte.PadRight(50, '-'));
67. foreach (T élément in éléments) {
68. Console.WriteLine(élément);
69. }
70. }
71.
72. // recherche d'un élément dans le tableau
73. // éléments : tableau de réels
74. // TypeRecherche : dichotomique ou linéaire
75. static void Recherche(double[] éléments, TypeRecherche type) {
76. // Recherche
77. bool terminé = false;
78. string réponse = null;
79. double élément = 0;
80. bool erreur = false;
81. int i = 0;
82. while (!terminé) {
83. // question
84. Console.WriteLine("Elément cherché (rien pour arrêter) : ");
85. // lecture-vérification réponse
86. réponse = Console.ReadLine().Trim();
87. // fini ?
88. if (réponse.Equals(""))
89. break;
90. // vérification
91. try {
92. élément = Double.Parse(réponse);
93. erreur = false;
94. } catch {
95. Console.WriteLine("Erreur, recommencez...");
96. erreur = true;
97. }//try-catch
98. // si pas d'erreur
99. if (!erreur) {
100. // on cherche l'élément dans le tableau
101. if (type == TypeRecherche.dichotomique)
102. // recherche dichotomique
103. i = Array.BinarySearch(éléments, élément);
104. else
105. // recherche linéaire
106. i = Array.IndexOf(éléments, élément);
107. // Affichage réponse
108. if (i >= 0)
109. Console.WriteLine("Trouvé en position " + i);
110. else
111. Console.WriteLine("Pas dans le tableau");
112. }//if
113. }//while
114. }
115.}

• lignes 27-62 : la méthode Saisie saisit les éléments d'un tableau éléments tapés au clavier. Comme on ne peut dimensionner le
tableau à priori (on ne connaît pas sa taille finale), on est obligés de le redimensionner à chaque nouvel élément (ligne 57).
Un algorithme plus efficace aurait été d'allouer de la place au tableau par groupe de N éléments. Un tableau n'est
cependant pas fait pour être redimensionné . Ce cas là est mieux traité avec une liste (ArrayList, List<T>).
• lignes 75-113 : la méthode Recherche permet de rechercher dans le tabeau éléments, un élément tapé au clavier. Le mode de
recherche est différent selon que le tableau est trié ou non. Pour un tableau non trié, on fait une recherche linéaire avec la
méthode IndexOf de la ligne 106. Pour un tableau trié, on fait une recherche dichotomique avec la méthode BinarySearch de
la ligne 103.
• ligne 18 : on trie le tableau éléments. On utilise ici, une variante de Sort qui n'a qu'un paramètre : le tableau à trier. La relation
d'ordre utilisée pour comparer les éléments du tableau est alors celle implicite de ces éléments. Ici, les éléments sont
numériques. C'est l'ordre naturel des nombres qui est utilisé.
Les résultats écran sont les suivants :
1. Elément (réel) 0 du tableau (rien pour terminer) : 3,6
2. Elément (réel) 1 du tableau (rien pour terminer) : 7,4
3. Elément (réel) 2 du tableau (rien pour terminer) : -1,5
4. Elément (réel) 3 du tableau (rien pour terminer) : -7
5. Elément (réel) 4 du tableau (rien pour terminer) :
6. Tableau non trié----------------------------------
7. 3,6
8. 7,4
9. -1,5
10.-7
11.Elément cherché (rien pour arrêter) :
12.7,4
13.Trouvé en position 1
14.Elément cherché (rien pour arrêter) :
15.0
16.Pas dans le tableau
17.Elément cherché (rien pour arrêter) :
18.
19.Tableau trié--------------------------------------
20.-7
21.-1,5
22.3,6
23.7,4
24.Elément cherché (rien pour arrêter) :
25.7,4
26.Trouvé en position 3
27.Elément cherché (rien pour arrêter) :
28.0
29.Pas dans le tableau
30.Elément cherché (rien pour arrêter) :

Publié par Drupal french Study