public void _50_Vider()
        {
            ArbreBin <int> ab = null;

            AreEqual(false, Vider(ref ab));
            IsNull(ab);
            foreach (var arbre in iArbres.Skip(1))
            {
                var a = arbre;
                AreEqual(true, Vider(ref a), arbre.EnTexte());
                IsNull(a, a.EnTexte());
            }
        }
        public void _61x_NouvelArbreBalancé()
        {
            ArbreBin <int> ab = NouvelArbreBalancé(new int[0]);

            AreEqual("n", ab.EnTexte());

            ab = NouvelArbreBalancé(Enumerable.Range(1, 15).ToArray());
            AreEqual("8f + 0t + 7e = 15n", ÉquationFTEN(ab));

            ab = NouvelArbreBalancé(Enumerable.Range(1, 16).ToArray());
            AreEqual("8f + 1t + 7e = 16n", ÉquationFTEN(ab));

            ThrowsException <ArgumentException>(() => NouvelArbreBalancé(new[] { 2, 2 }));
            ThrowsException <ArgumentException>(() => NouvelArbreBalancé(new[] { 2, 1 }));
        }
        public void _46a_AjouterPlusieurs()
        {
            ArbreBin <int> ab = null;

            AreEqual(5, Ajouter(ref ab, new [] { 5, 5, 2, 2, 9, 9, 7, 7, 4, 4, 5 }));
            AreEqual("n 4 2 | 7 n 9 | 5 |", ab.EnTexte());

            ab = null;
            AreEqual(5, Ajouter(ref ab, new[] { 1, 2, 3, 4, 5 }));
            AreEqual("n n n n 5 4 | 3 | 2 | 1 |", ab.EnTexte());

            ab = null;
            AreEqual(5, Ajouter(ref ab, new[] { 5, 4, 3, 2, 1 }));
            AreEqual("1 n 2 | n 3 | n 4 | n 5 |", ab.EnTexte());
        }
Esempio n. 4
0
        static partial void AfficherStats6 <T>(ArbreBin <T, T> .Noeud?arbre)
            where T : notnull, IComparable <T>
        {
            if (Program.STEP < 4500)
            {
                return;
            }

            if (Afficher(nameof(MaxP), () => ArbreBin <T, T> .MaxP(arbre)))
            {
                WriteLine();
            }

            foreach (string chemin in new [] { "GDG", "", "DX" })
            {
                _ = Afficher($"{nameof(CheminerR)}(\"{chemin}\")", () => ArbreBin <T, T> .CheminerR(arbre, chemin));
            }
            WriteLine();
        }
        public void _60x_Balancer()
        {
            ArbreBin <int> ab = null;

            IsTrue(EstBalancé(ab), "Car un arbre vide est considéré balancé");
            IsFalse(Balancer(ref ab), "Car on a pas besoin de le balancer");

            Ajouter(ref ab, Enumerable.Range(1, 15));
            IsFalse(EstBalancé(ab), "Car il est linéaire");
            IsTrue(Balancer(ref ab), "Car on peut le balancer");
            IsTrue(EstBalancé(ab), "Car il est maintenant balancé");
            IsFalse(Balancer(ref ab), "Car on a pas besoin de le rebalancé");
            AreEqual("8f + 0t + 7e = 15n", ÉquationFTEN(ab));

            Vider(ref ab);
            Ajouter(ref ab, Enumerable.Range(1, 16));
            IsTrue(Balancer(ref ab), "Car on peut le balancer");
            AreEqual("8f + 1t + 7e = 16n", ÉquationFTEN(ab));
        }
Esempio n. 6
0
        public static void Afficher <T>(int indice, ArbreBin <T, T> .Noeud?arbre)
            where T : notnull, IComparable <T>
        {
            Indice = indice;

            // Méthodes et propriétés nodales
            if (arbre != null && MenuArbres.StatLevels.Contains(1))
            {
                var aff = false;
                aff |= Afficher("Espèce(racine)", () => arbre.Espèce);
                aff |= Afficher("ToString(racine)", () => arbre.ToString());
                if (arbre.Droite != null)
                {
                    aff |= Afficher("ToString(racine.Droite)", () => arbre.Droite.ToString());
                }
                if (aff)
                {
                    WriteLine();
                }
            }

            if (MenuArbres.StatLevels.Contains(2))
            {
                AfficherStats2(arbre);
            }
            if (MenuArbres.StatLevels.Contains(3))
            {
                AfficherStats3(arbre);
            }
            if (MenuArbres.StatLevels.Contains(4))
            {
                AfficherStats4(arbre);
            }
            if (MenuArbres.StatLevels.Contains(5))
            {
                AfficherStats5(arbre);
            }
            if (MenuArbres.StatLevels.Contains(6))
            {
                AfficherStats6(arbre);
            }
        }
Esempio n. 7
0
        static partial void AfficherStats4 <T>(ArbreBin <T, T> .Noeud?arbre)
            where T : notnull, IComparable <T>
        {
            if (Program.STEP <= 4000)
            {
                return;
            }

            if (Afficher(nameof(SyntaxePostfixée), () => ArbreBin <T, T> .SyntaxePostfixée(arbre).Raccourcir(60)) &&
                Afficher(nameof(PostOrdre), () => arbre.Lister(ArbreBin <T, T> .PostOrdre))
                )
            {
                WriteLine();
            }

            if (Afficher(nameof(SyntaxePréfixée), () => ArbreBin <T, T> .SyntaxePréfixée(arbre).Raccourcir(60)) &&
                Afficher(nameof(PréOrdre), () => arbre.Lister(ArbreBin <T, T> .PréOrdre))
                )
            {
                WriteLine();
            }

            if (Afficher(nameof(SyntaxeInfixée), () => ArbreBin <T, T> .SyntaxeInfixée(arbre).Raccourcir(60)) &&
                Afficher(nameof(EnOrdre), () => arbre.Lister(ArbreBin <T, T> .EnOrdre))
                )
            {
                WriteLine();
            }

            if (false
                | Afficher(nameof(EvalInt), () => ArbreBin <T, T> .EvalInt(arbre))
                | Afficher(nameof(EvalDouble), () => ArbreBin <T, T> .EvalDouble(arbre))
                )
            {
                WriteLine();
            }
        }
Esempio n. 8
0
 static partial void AfficherStats6 <T>(ArbreBin <T, T> .Noeud?arbre)
     where T : notnull, IComparable <T>;
Esempio n. 9
0
 public static string EnTexte <T>(this ArbreBin <T> ab) where T : IComparable <T>
 {
     return(ArbreBin <T> .Format(ab));
 }
Esempio n. 10
0
 Format(ArbreBin <T> ab)
 {
     return(ab?.ToString() ?? "n");
 }