using System;

using System.Collections;

using System.Collections.Generic;

​

var lst = new Liste<string>();

foreach (var s in new[] { "J'aime", "mon", "prof" })

   lst.AjouterFin(s);

lst.Accepter(s => Console.Write($"{s} "));

Console.WriteLine();

string plusseLongue = null;

lst.Accepter(s =>

{

   if (plusseLongue == null || s.Length > plusseLongue.Length)

      plusseLongue = s;

});

Console.WriteLine($"Chaîne la plusse longue : {plusseLongue}");

string plusseCourte = null;

lst.Accepter(s =>

{

   if (plusseCourte == null || s.Length < plusseCourte.Length)

      plusseCourte = s;

});

Console.WriteLine($"Chaîne la plusse courte : {plusseCourte}");

​

​

class ListeVideException : Exception { }

// modélise une liste simplement chaînée dont chaque noeud "contient" un T

class Liste<T> : IEnumerable<T> where T : IEquatable<T>

{

   public IEnumerator<T> GetEnumerator() =>

      new Énumérateur(Tête);

   IEnumerator IEnumerable.GetEnumerator() =>

      new Énumérateur(Tête);

   // un énumérateur de C# / un itérateur de Java, modélise

   // une séquence à demi ouverte (debut, fin]

   class Énumérateur : IEnumerator<T>

   {

      Noeud Cur { get; set; }

      public Énumérateur(Noeud tête)

      {

         Cur = new (default);

         Cur.Succ = tête;

      }

      public bool MoveNext()

      {

         if (Cur.Succ == null)

            return false;

         Cur = Cur.Succ;

         return true;

      }

      public void Reset() => throw new NotImplementedException();

      public void Dispose() { }

      public T Current => Cur.Valeur;

      object IEnumerator.Current => Cur.Valeur;

   }

   class Noeud

   {

      public T Valeur { get; init; }

      public Noeud Succ { get; set; } = null;

      public Noeud(T val)

      {

         Valeur = val;

      }

   }

   Noeud Tête { get; set; } = null;

   Noeud Queue { get; set; } = null;

   public bool EstVide => Tête == null;

   public void AjouterDébut(T val)

   {

      var noeud = new Noeud(val);

      if (EstVide)

         Tête = Queue = noeud;

      else

      {

         noeud.Succ = Tête;

         Tête = noeud;

      }

      ++Count;

   }

   public void AjouterFin(T val)

   {

      Noeud noeud = new (val);

      if (EstVide)

         Tête = Queue = noeud;

      else

      {

         Queue.Succ = noeud;

         Queue = noeud;

      }

      ++Count;

   }

   public void SupprimerDébut()

   {

      if (EstVide)

         throw new ListeVideException();

      Tête = Tête.Succ;

      if (Tête == null)

         Queue = null;

      --Count;

   }

   public T PeekDébut() =>

      EstVide? throw new ListeVideException(): Tête.Valeur;

   public T PeekFin()

   {

      if (EstVide)

         throw new ListeVideException();

      return Queue.Valeur;

   }

   //public static Liste<T> Dupliquer(Liste<T> src)

   //{

   //   Liste<T> dest = new();

    //   for (Noeud p = src.Tête; p != null; p = p.Succ)

   //      dest.AjouterFin(p.Valeur);

   //   return dest;

   //}

   public Liste<T> Dupliquer()

   {

      Liste<T> dest = new();

      for (Noeud p = Tête; p != null; p = p.Succ)

         dest.AjouterFin(p.Valeur);

      return dest;

   }

   public int Count { get; private set; } = 0;

   public void ForEach(Action<T> f)

   {

      foreach(T val in this)

         f(val);

   }

   public bool Contains(T elem)

   {

      foreach(T val in this)

         if(val.Equals(elem))

            return true;

      return false;

   }

   public Liste()

   {

   }

   public Liste(IEnumerable<T> objs)

   {

      foreach (T e in objs)

         AjouterFin(e);

   }

   public void Accepter(Action<T> f)

   {

      ForEach(f);

   }

}