Discussion :

[david71]

Salut,

Voilà j'ai un problème de tri en C# que je ne sais pas comment résoudre.

Je souhaite faire un tri par ordre croissant de chaîne contenue dans une autre chaîne.

La liste est par exemple la suivante :

120123456
120030454
121004564

Je souhaite faire un tri sur les éléments en gras donc avoir en retour la liste suivante :

121004564
120030454
120123456

Vous avez des suggestions ?
Merci d'avance pour toute information complémentaire.

[Sphax]

Salut,

Oui tu peux implémenter ton propre objet de comparaison (il doit implémenter l'interface IComparer je crois). tu pourras l'utiliser pour trier un ArrayList de tes chaines sur la condition que tu veux.

[Maniak]

Cherche ArrayList.Sort dans MSDN

Y a même un exemple avec tout ce qu'il faut, sauf les Substring.

[neguib]

Exemple testé sur Console :

• 1. une classe specifique pour ton type de chaine
  

  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
   
  public class MaChaine
  {
      private string racine;
      private string suite;
   
      public MaChaine(string root, string value)
      {
          this.racine = root;
          this.suite = value;
      }
      public string Root 
      {
          get { return this.racine;}
          set { this.racine = value;}
      }
      public string Value
      {
          get { return this.suite;}
          set { this.suite = value;}
      }
      public override string ToString()
      { return (this.racine + this.suite);}
  }

  2. La collection correspondante et le IComparer
  

  Code :

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

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
   
  public class MesChaines : List<MaChaine>
  {
      public void Sort()
      { base.Sort(new MaChaineComparer());}
  }
  public class MaChaineComparer : IComparer<MaChaine>
  {
      public int Compare(MaChaine maChaine1, MaChaine maChaine2)
      { return (maChaine1.Value.CompareTo(maChaine2.Value));}
  }

  3. Le test Console
  

  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
  public class Main
  {
      static void Main()
      { TestSubSort();}
   
      private static void TestSubSort()
      {
          MesChaines liste = new MesChaines();
          liste.Add(new MaChaine("120", "123456"));
          liste.Add(new MaChaine("120", "030454"));
          liste.Add(new MaChaine("121", "004564"));
          foreach (MaChaine s in liste)
          { Console.WriteLine(s.ToString());}
          Console.WriteLine("*********");
          liste.Sort();
          foreach (MaChaine s in liste)
          { Console.WriteLine(s.ToString());}
          Console.ReadLine();
      }
  }

  4.
  

  120123456
  120030454
  121004564
  *********
  121004564
  120030454
  120123456

Pour la 1.1, tu dois suivre la même idée mais sans les fonctionnalités des generics, que tu devras contourner ou implementer toi même

[Maniak]

Si je puis me permettre d'être lourd, il y a un *poil* plus simple/court

En 1.1 :

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
	public class Application
	{
		private static void Main()
		{
			TestSubSort2();
		}
 
		private static void TestSubSort2()
		{
			string[] strings = { "120123456", "120030454", "121004564" };
			WriteStrings( strings );
			Console.WriteLine( "*********" );
 
			Array.Sort( strings, new SubstringComparer() );
 
			WriteStrings( strings );
		}
 
		private static void WriteStrings( string[] strings )
		{
			foreach ( string item in strings )
			{
				Console.WriteLine( item );
			}
		}
 
		private class SubstringComparer : IComparer
		{
			public int Compare( object x, object y )
			{
				string left = x as string;
				string right = y as string;
 
				return left.Substring( 3 ).CompareTo( right.Substring( 3 ) );
			}
		}

(version bourrin sans vérifier que la longueur des chaînes doit être > 3)

En 2.0, on vire SubstringComparer, et on remplace Array.Sort(...) par :

Code :

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

1
2
3
4
5
			Array.Sort(
				strings, delegate( string x, string y )
				         	{
				         		return x.Substring( 3 ).CompareTo( y.Substring( 3 ) );
				         	} );

Maintenant si les chaînes en question ont vraiment besoin d'être traitées comme deux chaînes composées, matérialiser ça par une classe spécialisée est recommandé. Mais si c'est juste pour le tri, pas besoin de trop se compliquer la vie non plus

[david71]

OK, merci ton exemple marche, mais pas avec les chaînes suivantes à trier :

Code :

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

1
2
 
string[] strings = { "12000751234560273123456780010316", "1200075123456027312345678001W316","12000132809720341000050520010136", "12000132809720341000050520020135","12001750204750482047500830030925" };

Avec :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
private class SubstringComparer : IComparer 
		{ 
			public int Compare( object x, object y ) 
			{ 
				string left = x as string;
				string right = y as string;				
 
				return left.Substring(7,18).CompareTo(right.Substring(7,18)); 
			} 
		}

L'ordre n'est pas bon. Quelqu'un voit pourquoi ?
Merci d'avance.

Oups, je me suis trompé dans les positions de la sous chaine .
Bon en fait ça marche ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
private class SubstringComparer : IComparer 
      { 
         public int Compare( object x, object y ) 
         { 
            string left = x as string; 
            string right = y as string;             
 
            return left.Substring(17,8).CompareTo(right.Substring(17,8)); 
         } 
      }