Mirai/ALGA
1
0
Fork 0
mirror of https://github.com/Lendaia/oe-alga-feladatok.git synced 2026-04-23 04:16:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

fortheloveofgod

Browse Source
This commit is contained in:
Lendaia Mirai
2026-01-12 00:31:22 +01:00
parent 04fc53bbc7
commit b18d3cd9f1
5 changed files with 618 additions and 512 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
ALGA/Adatszerkezetek/05_BinarisKeresoFa.cs
View File

@@ -2,7 +2,7 @@
namespace OE.ALGA;
internal class FaElem<T> where T : IComparable
public class FaElem<T> where T : IComparable
{
public T? tart;
public FaElem<T>? bal;
@@ -17,7 +17,7 @@ internal class FaElem<T> where T : IComparable
}
public class FaHalmaz<T> : Halmaz<T> where T : IComparable
{
FaElem<T>? gyoker;
public FaElem<T>? gyoker;
private void BejarasPreOrder(FaElem<T> p, Action<T> muvelet)
{

116
ALGA/Adatszerkezetek/12_SulyozottGraf.cs
View File

@@ -1,4 +1,7 @@
using System;
using System.Data;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace OE.ALGA.Adatszerkezetek
{
@@ -10,6 +13,7 @@ namespace OE.ALGA.Adatszerkezetek
Suly = suly;
}
}
public class CsucsmatrixSulyozottEgeszGraf : SulyozottGraf<int, SulyozottEgeszGrafEl>
{
@@ -26,7 +30,7 @@ namespace OE.ALGA.Adatszerkezetek
{
for (int j = 0; j < n; j++)
{
if (M[i,j] != null)
if (M[i,j] != 0.0)
{
elek++;
}
@@ -62,7 +66,7 @@ namespace OE.ALGA.Adatszerkezetek
{
for (int j = 0; j < n; j++)
{
if (M[i,j] != null)
if (M[i,j] != 0.0)
{
SulyozottEgeszGrafEl egeszgrafel = new SulyozottEgeszGrafEl(i, j, M[i,j]);
fahalmaz.Beszur(egeszgrafel);
@@ -75,7 +79,7 @@ namespace OE.ALGA.Adatszerkezetek
public float Suly(int honnan, int hova)
{
if(M[honnan, hova] != null)
if(M[honnan, hova] != 0.0)
{
return M[honnan, hova];
}
@@ -90,7 +94,7 @@ namespace OE.ALGA.Adatszerkezetek
FaHalmaz<int> fahalmaz = new FaHalmaz<int>();
for (int i = 0; i < n; i++)
{
if (M[csucs, i] != null)
if (M[csucs, i] != 0.0)
{
fahalmaz.Beszur(i);
}
@@ -105,7 +109,109 @@ namespace OE.ALGA.Adatszerkezetek
public bool VezetEl(int honnan, int hova)
{
return (M[honnan, hova]!= null);
return (M[honnan, hova]!= 0.0);
}
}
public class Utkereses
{
public static Szotar<V, float> Dijkstra<V, E>(SulyozottGraf<V, E> g, V start) where V: IComparable
{
Szotar<V, float> legrovidebb = new HasitoSzotarTulcsordulasiTerulettel<V, float>(g.CsucsokSzama);
Szotar<V, V> P = new HasitoSzotarTulcsordulasiTerulettel<V,V>(g.CsucsokSzama);
KupacPrioritasosSor<V> S = new KupacPrioritasosSor<V>(g.CsucsokSzama, (ez, ennel) => legrovidebb.Kiolvas(ez) < legrovidebb.Kiolvas(ennel));
g.Csucsok.Bejar(x =>
{
legrovidebb.Beir(x, int.MaxValue);
S.Sorba(x);
});
legrovidebb.Beir(start, 0);
S.Frissit(start);
while(!S.Ures)
{
V u = S.Sorbol();
g.Szomszedai(u).Bejar(x =>
{
if(legrovidebb.Kiolvas(u) + g.Suly(u,x) < legrovidebb.Kiolvas(x))
{
legrovidebb.Beir(x, legrovidebb.Kiolvas(u) + g.Suly(u,x));
P.Beir(x, u);
S.Frissit(x);
}
});
}
return legrovidebb;
}
}
public class FeszitofaKereses
{
public static Szotar<V, V> Prim<V, E>(SulyozottGraf<V, E> g, V start) where V: IComparable
{
Szotar<V, float> feszito = new HasitoSzotarTulcsordulasiTerulettel<V, float>(g.CsucsokSzama);
Szotar<V, V> P = new HasitoSzotarTulcsordulasiTerulettel<V,V>(g.CsucsokSzama);
KupacPrioritasosSor<V> S = new KupacPrioritasosSor<V>(g.CsucsokSzama, (ez, ennel) => feszito.Kiolvas(ez) < feszito.Kiolvas(ennel));
FaHalmaz<V> helper = new FaHalmaz<V>();
g.Csucsok.Bejar(x =>
{
feszito.Beir(x, int.MaxValue);
S.Sorba(x);
helper.Beszur(x);
});
feszito.Beir(start, 0);
S.Frissit(start);
while(!S.Ures && helper.gyoker != null)
{
V minimum = S.Sorbol();
helper.Torol(minimum);
g.Szomszedai(minimum).Bejar(x =>
{
if(helper.Eleme(x) && g.Suly(x, minimum) < feszito.Kiolvas(x))
{
feszito.Beir(x, g.Suly(x, minimum));
P.Beir(x, minimum);
}
});
}
return P;
}
public static Halmaz<E> Kruskal<V, E>(SulyozottGraf<V, E> g) where E: SulyozottGrafEl<V>, IComparable
{
FaHalmaz<E> feszitofa = new FaHalmaz<E>();
Szotar<V, int> vhalmaz = new HasitoSzotarTulcsordulasiTerulettel<V, int>(g.CsucsokSzama);
int i = 0;
g.Csucsok.Bejar(x => {vhalmaz.Beir(x, i++);});
g.Elek.Bejar(e => {feszitofa.Beszur(e);});
while(feszitofa.gyoker != null)
{
E minimum = feszitofa.gyoker.tart;
feszitofa.Bejar(x =>
{
if(minimum.Suly > x.Suly)
{
minimum = x;
}
});
feszitofa.Torol(minimum);
if (vhalmaz.Kiolvas(minimum.Honnan) != vhalmaz.Kiolvas(minimum.Hova))
{
vhalmaz.Beir(minimum.Honnan, vhalmaz.Kiolvas(minimum.Hova));
}
}
return feszitofa;
}
}
}

306
Tesztek/02_FunkconalisParadigmaTesztek.cs
View File

@@ -1,154 +1,154 @@
//using NUnit.Framework;
//using OE.ALGA.Paradigmak;
using NUnit.Framework;
using OE.ALGA.Paradigmak;
//namespace OE.ALGA.Tesztek.Paradigmak
//{
// [TestFixture(Category = "Paradigmák", TestName = "02 - Feltételes Feladat Tároló Tesztek")]
// public class FeltetelesFeladatTaroloTesztek
// {
// [TestCase]
// public void Felvesz()
// {
// FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(5);
// TesztFeladat a = new TesztFeladat("a");
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// }
// [TestCase]
// public void TulsokatFelvesz()
// {
// FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(3);
// TesztFeladat a = new TesztFeladat("a");
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
// }
// [TestCase]
// public void NincsMitVegrehajtani()
// {
// FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(2);
// tarolo.MindentVegrehajt();
// }
// [TestCase]
// public void MindenVegrehajtas()
// {
// FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(2);
// TesztFeladat a = new TesztFeladat("a");
// TesztFeladat b = new TesztFeladat("b");
// tarolo.Felvesz(a);
// tarolo.Felvesz(b);
// Assert.Multiple(() =>
// {
// Assert.That(a.Vegrehajtott, Is.False);
// Assert.That(b.Vegrehajtott, Is.False);
// });
// tarolo.MindentVegrehajt();
// Assert.Multiple(() =>
// {
// Assert.That(a.Vegrehajtott, Is.True);
// Assert.That(b.Vegrehajtott, Is.True);
// });
// }
// [TestCase]
// public void FeltetelesVegrehajtas()
// {
// FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
// TesztFeladat a1 = new TesztFeladat("a1");
// TesztFeladat b1 = new TesztFeladat("b1");
// TesztFeladat a2 = new TesztFeladat("a2");
// tarolo.Felvesz(a1);
// tarolo.Felvesz(b1);
// tarolo.Felvesz(a2);
// Assert.Multiple(() =>
// {
// Assert.That(a1.Vegrehajtott, Is.False);
// Assert.That(b1.Vegrehajtott, Is.False);
// Assert.That(a2.Vegrehajtott, Is.False);
// });
// tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a'; }); // csak 'a' kezdetűek végrehajtása
// Assert.Multiple(() =>
// {
// Assert.That(a1.Vegrehajtott, Is.True);
// Assert.That(b1.Vegrehajtott, Is.False);
// Assert.That(a2.Vegrehajtott, Is.True);
// });
// tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'b'; }); // csak 'b' kezdetűek végrehajtása
// Assert.Multiple(() =>
// {
// Assert.That(a1.Vegrehajtott, Is.True);
// Assert.That(b1.Vegrehajtott, Is.True);
// Assert.That(a2.Vegrehajtott, Is.True);
// });
// }
// [TestCase]
// public void FeltetelesFuggosegesVegrehajtas()
// {
// FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10);
// TesztFuggoFeladat a1 = new TesztFuggoFeladat("a1") { Vegrehajthato = true };
// TesztFuggoFeladat b1 = new TesztFuggoFeladat("b1") { Vegrehajthato = true };
// TesztFuggoFeladat a2 = new TesztFuggoFeladat("a2") { Vegrehajthato = false };
// tarolo.Felvesz(a1);
// tarolo.Felvesz(b1);
// tarolo.Felvesz(a2);
// Assert.Multiple(() =>
// {
// Assert.That(a1.Vegrehajtott, Is.False);
// Assert.That(b1.Vegrehajtott, Is.False);
// Assert.That(a2.Vegrehajtott, Is.False);
// });
// tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a' && x.FuggosegTeljesul; }); // csak 'a' kezdetű és végrehajtható
// Assert.Multiple(() =>
// {
// Assert.That(a1.Vegrehajtott, Is.True);
// Assert.That(b1.Vegrehajtott, Is.False);
// Assert.That(a2.Vegrehajtott, Is.False);
// });
// tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'b' && x.FuggosegTeljesul; }); // csak 'b' kezdetű és végrehajtható
// Assert.Multiple(() =>
// {
// Assert.That(a1.Vegrehajtott, Is.True);
// Assert.That(b1.Vegrehajtott, Is.True);
// Assert.That(a2.Vegrehajtott, Is.False);
// });
// a2.Vegrehajthato = true;
// tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a' && x.FuggosegTeljesul; }); // csak 'a' kezdetű és végrehajtható
// Assert.Multiple(() =>
// {
// Assert.That(a1.Vegrehajtott, Is.True);
// Assert.That(b1.Vegrehajtott, Is.True);
// Assert.That(a2.Vegrehajtott, Is.True);
// });
// }
// [TestCase]
// public void Bejaro()
// {
// FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
// TesztFeladat a = new TesztFeladat("a");
// TesztFeladat b = new TesztFeladat("b");
// tarolo.Felvesz(a);
// tarolo.Felvesz(b);
// string nevek = "";
// foreach (TesztFeladat u in tarolo)
// nevek += u.Azonosito;
// Assert.That(nevek, Is.EqualTo("ab"));
// }
// [TestCase]
// public void FeltetelesBejaro()
// {
// FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10);
// tarolo.BejaroFeltetel = (x => { Guardian.Recursion.CheckStackTrace(); return x.FuggosegTeljesul; });
// TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
// TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = false };
// TesztFuggoFeladat c = new TesztFuggoFeladat("c") { Vegrehajthato = true };
// tarolo.Felvesz(a);
// tarolo.Felvesz(b);
// tarolo.Felvesz(c);
// string nevek = "";
// foreach (TesztFeladat u in tarolo)
// nevek += u.Azonosito;
// Assert.That(nevek, Is.EqualTo("ac"));
// }
// }
//}
namespace OE.ALGA.Tesztek.Paradigmak
{
[TestFixture(Category = "Paradigmák", TestName = "02 - Feltételes Feladat Tároló Tesztek")]
public class FeltetelesFeladatTaroloTesztek
{
[TestCase]
public void Felvesz()
{
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(5);
TesztFeladat a = new TesztFeladat("a");
tarolo.Felvesz(a);
tarolo.Felvesz(a);
tarolo.Felvesz(a);
}
[TestCase]
public void TulsokatFelvesz()
{
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(3);
TesztFeladat a = new TesztFeladat("a");
tarolo.Felvesz(a);
tarolo.Felvesz(a);
tarolo.Felvesz(a);
Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
}
[TestCase]
public void NincsMitVegrehajtani()
{
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(2);
tarolo.MindentVegrehajt();
}
[TestCase]
public void MindenVegrehajtas()
{
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(2);
TesztFeladat a = new TesztFeladat("a");
TesztFeladat b = new TesztFeladat("b");
tarolo.Felvesz(a);
tarolo.Felvesz(b);
Assert.Multiple(() =>
{
Assert.That(a.Vegrehajtott, Is.False);
Assert.That(b.Vegrehajtott, Is.False);
});
tarolo.MindentVegrehajt();
Assert.Multiple(() =>
{
Assert.That(a.Vegrehajtott, Is.True);
Assert.That(b.Vegrehajtott, Is.True);
});
}
[TestCase]
public void FeltetelesVegrehajtas()
{
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
TesztFeladat a1 = new TesztFeladat("a1");
TesztFeladat b1 = new TesztFeladat("b1");
TesztFeladat a2 = new TesztFeladat("a2");
tarolo.Felvesz(a1);
tarolo.Felvesz(b1);
tarolo.Felvesz(a2);
Assert.Multiple(() =>
{
Assert.That(a1.Vegrehajtott, Is.False);
Assert.That(b1.Vegrehajtott, Is.False);
Assert.That(a2.Vegrehajtott, Is.False);
});
tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a'; }); // csak 'a' kezdetűek végrehajtása
Assert.Multiple(() =>
{
Assert.That(a1.Vegrehajtott, Is.True);
Assert.That(b1.Vegrehajtott, Is.False);
Assert.That(a2.Vegrehajtott, Is.True);
});
tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'b'; }); // csak 'b' kezdetűek végrehajtása
Assert.Multiple(() =>
{
Assert.That(a1.Vegrehajtott, Is.True);
Assert.That(b1.Vegrehajtott, Is.True);
Assert.That(a2.Vegrehajtott, Is.True);
});
}
[TestCase]
public void FeltetelesFuggosegesVegrehajtas()
{
FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10);
TesztFuggoFeladat a1 = new TesztFuggoFeladat("a1") { Vegrehajthato = true };
TesztFuggoFeladat b1 = new TesztFuggoFeladat("b1") { Vegrehajthato = true };
TesztFuggoFeladat a2 = new TesztFuggoFeladat("a2") { Vegrehajthato = false };
tarolo.Felvesz(a1);
tarolo.Felvesz(b1);
tarolo.Felvesz(a2);
Assert.Multiple(() =>
{
Assert.That(a1.Vegrehajtott, Is.False);
Assert.That(b1.Vegrehajtott, Is.False);
Assert.That(a2.Vegrehajtott, Is.False);
});
tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a' && x.FuggosegTeljesul; }); // csak 'a' kezdetű és végrehajtható
Assert.Multiple(() =>
{
Assert.That(a1.Vegrehajtott, Is.True);
Assert.That(b1.Vegrehajtott, Is.False);
Assert.That(a2.Vegrehajtott, Is.False);
});
tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'b' && x.FuggosegTeljesul; }); // csak 'b' kezdetű és végrehajtható
Assert.Multiple(() =>
{
Assert.That(a1.Vegrehajtott, Is.True);
Assert.That(b1.Vegrehajtott, Is.True);
Assert.That(a2.Vegrehajtott, Is.False);
});
a2.Vegrehajthato = true;
tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a' && x.FuggosegTeljesul; }); // csak 'a' kezdetű és végrehajtható
Assert.Multiple(() =>
{
Assert.That(a1.Vegrehajtott, Is.True);
Assert.That(b1.Vegrehajtott, Is.True);
Assert.That(a2.Vegrehajtott, Is.True);
});
}
[TestCase]
public void Bejaro()
{
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
TesztFeladat a = new TesztFeladat("a");
TesztFeladat b = new TesztFeladat("b");
tarolo.Felvesz(a);
tarolo.Felvesz(b);
string nevek = "";
foreach (TesztFeladat u in tarolo)
nevek += u.Azonosito;
Assert.That(nevek, Is.EqualTo("ab"));
}
[TestCase]
public void FeltetelesBejaro()
{
FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10);
tarolo.BejaroFeltetel = (x => { Guardian.Recursion.CheckStackTrace(); return x.FuggosegTeljesul; });
TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = false };
TesztFuggoFeladat c = new TesztFuggoFeladat("c") { Vegrehajthato = true };
tarolo.Felvesz(a);
tarolo.Felvesz(b);
tarolo.Felvesz(c);
string nevek = "";
foreach (TesztFeladat u in tarolo)
nevek += u.Azonosito;
Assert.That(nevek, Is.EqualTo("ac"));
}
}
}

220
Tesztek/06_SzotarTesztek.cs
View File

@@ -1,112 +1,112 @@
//using NUnit.Framework;
//using OE.ALGA.Adatszerkezetek;
using NUnit.Framework;
using OE.ALGA.Adatszerkezetek;
//namespace OE.ALGA.Tesztek.Adatszerkezetek
//{
// [TestFixture(Category = "Adatszerkezetek", TestName = "06 - Szótár Tesztek")]
// public class SzotarTesztek
// {
// private static int TesztHasitoFuggveny(string kulcs)
// {
// if (string.IsNullOrEmpty(kulcs))
// return 0;
// int sum = 0;
// foreach (char c in kulcs.ToCharArray())
// sum += ((byte)c);
// return sum * sum; // a modulo osztást a szótárnak kell végeznie, mert ő tudja csak a belső tömb méretet
// }
namespace OE.ALGA.Tesztek.Adatszerkezetek
{
[TestFixture(Category = "Adatszerkezetek", TestName = "06 - Szótár Tesztek")]
public class SzotarTesztek
{
private static int TesztHasitoFuggveny(string kulcs)
{
if (string.IsNullOrEmpty(kulcs))
return 0;
int sum = 0;
foreach (char c in kulcs.ToCharArray())
sum += ((byte)c);
return sum * sum; // a modulo osztást a szótárnak kell végeznie, mert ő tudja csak a belső tömb méretet
}
// [TestCase]
// public void AlapMukodes()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// Assert.Multiple(() =>
// {
// Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
// Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// });
// }
// [TestCase]
// public void AlapertelmezettHasitoFuggvennyel() //F2.(f)
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// Assert.Multiple(() =>
// {
// Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
// Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// });
// }
// [TestCase]
// public void Kulcsutkozes()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Bale", 15);
// sz.Beir("Lajos", 2);
// sz.Beir("Lasoj", 12);
// Assert.Multiple(() =>
// {
// Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
// Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// Assert.That(sz.Kiolvas("Bale"), Is.EqualTo(15));
// Assert.That(sz.Kiolvas("Lasoj"), Is.EqualTo(12));
// });
// }
// [TestCase]
// public void NullElem()
// {
// Szotar<string, string> sz = new HasitoSzotarTulcsordulasiTerulettel<string, string>(5, TesztHasitoFuggveny);
// sz.Beir("null", null!);
// }
// [TestCase]
// public void UresKulcs()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("", 0);
// }
// [TestCase]
// public void UresElem()
// {
// Szotar<string, string> sz = new HasitoSzotarTulcsordulasiTerulettel<string, string>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", "");
// }
// [TestCase]
// public void NincsElem()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// Assert.Throws<HibasKulcsKivetel>(() => sz.Kiolvas("Ferenc"));
// }
// [TestCase]
// public void TorlesNull()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// Assert.Throws<HibasKulcsKivetel>(() => sz.Torol(null!));
// }
// [TestCase]
// public void TorlesMarad()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// sz.Torol("Bela");
// Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// }
// [TestCase]
// public void TorlesEltunt()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// sz.Torol("Bela");
// Assert.Throws<HibasKulcsKivetel>(() => sz.Kiolvas("Bela"));
// }
// }
//}
[TestCase]
public void AlapMukodes()
{
Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
sz.Beir("Bela", 5);
sz.Beir("Lajos", 2);
Assert.Multiple(() =>
{
Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
});
}
[TestCase]
public void AlapertelmezettHasitoFuggvennyel() //F2.(f)
{
Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10);
sz.Beir("Bela", 5);
sz.Beir("Lajos", 2);
Assert.Multiple(() =>
{
Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
});
}
[TestCase]
public void Kulcsutkozes()
{
Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
sz.Beir("Bela", 5);
sz.Beir("Bale", 15);
sz.Beir("Lajos", 2);
sz.Beir("Lasoj", 12);
Assert.Multiple(() =>
{
Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
Assert.That(sz.Kiolvas("Bale"), Is.EqualTo(15));
Assert.That(sz.Kiolvas("Lasoj"), Is.EqualTo(12));
});
}
[TestCase]
public void NullElem()
{
Szotar<string, string> sz = new HasitoSzotarTulcsordulasiTerulettel<string, string>(5, TesztHasitoFuggveny);
sz.Beir("null", null!);
}
[TestCase]
public void UresKulcs()
{
Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
sz.Beir("", 0);
}
[TestCase]
public void UresElem()
{
Szotar<string, string> sz = new HasitoSzotarTulcsordulasiTerulettel<string, string>(5, TesztHasitoFuggveny);
sz.Beir("Bela", "");
}
[TestCase]
public void NincsElem()
{
Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
sz.Beir("Bela", 5);
sz.Beir("Lajos", 2);
Assert.Throws<HibasKulcsKivetel>(() => sz.Kiolvas("Ferenc"));
}
[TestCase]
public void TorlesNull()
{
Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
sz.Beir("Bela", 5);
sz.Beir("Lajos", 2);
Assert.Throws<HibasKulcsKivetel>(() => sz.Torol(null!));
}
[TestCase]
public void TorlesMarad()
{
Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
sz.Beir("Bela", 5);
sz.Beir("Lajos", 2);
sz.Torol("Bela");
Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
}
[TestCase]
public void TorlesEltunt()
{
Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
sz.Beir("Bela", 5);
sz.Beir("Lajos", 2);
sz.Torol("Bela");
Assert.Throws<HibasKulcsKivetel>(() => sz.Kiolvas("Bela"));
}
}
}

484
Tesztek/12_SulyozottGrafTesztek.cs
View File

@@ -1,278 +1,278 @@
//using NUnit.Framework;
//using OE.ALGA.Adatszerkezetek;
using NUnit.Framework;
using OE.ALGA.Adatszerkezetek;
//namespace OE.ALGA.Tesztek.Adatszerkezetek
//{
// [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Csúcs Mátrix Súlyozott Gráf Tesztek")]
// public class CsucsMatrixSulyozottGrafTesztek
// {
// [TestCase]
// public void MindenCsucsTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
// Assert.Multiple(() =>
// {
// Assert.That(csg.Csucsok.Eleme(0), Is.True);
// Assert.That(csg.Csucsok.Eleme(1), Is.True);
// });
// }
namespace OE.ALGA.Tesztek.Adatszerkezetek
{
[TestFixture(Category = "Adatszerkezetek", TestName = "12 - Csúcs Mátrix Súlyozott Gráf Tesztek")]
public class CsucsMatrixSulyozottGrafTesztek
{
[TestCase]
public void MindenCsucsTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
Assert.Multiple(() =>
{
Assert.That(csg.Csucsok.Eleme(0), Is.True);
Assert.That(csg.Csucsok.Eleme(1), Is.True);
});
}
// [TestCase]
// public void MindenElTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 2, 2.0f);
// csg.UjEl(1, 2, 3.0f);
[TestCase]
public void MindenElTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
csg.UjEl(0, 1, 1.0f);
csg.UjEl(0, 2, 2.0f);
csg.UjEl(1, 2, 3.0f);
// Assert.Multiple(() =>
// {
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 0, 0.0f)), Is.False);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 1.0f)), Is.True);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 2.0f)), Is.True);
Assert.Multiple(() =>
{
Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 0, 0.0f)), Is.False);
Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 1.0f)), Is.True);
Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 2.0f)), Is.True);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 0, 0.0f)), Is.False);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 1, 0.0f)), Is.False);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 3.0f)), Is.True);
Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 0, 0.0f)), Is.False);
Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 1, 0.0f)), Is.False);
Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 3.0f)), Is.True);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 0, 0.0f)), Is.False);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 1, 0.0f)), Is.False);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 2, 0.0f)), Is.False);
// });
// }
Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 0, 0.0f)), Is.False);
Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 1, 0.0f)), Is.False);
Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 2, 0.0f)), Is.False);
});
}
// [TestCase]
// public void VezetElTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
// Assert.That(csg.VezetEl(0, 1), Is.False);
// csg.UjEl(0, 1, 1.0f);
// Assert.Multiple(() =>
// {
// Assert.That(csg.VezetEl(0, 1), Is.True);
// Assert.That(csg.VezetEl(1, 0), Is.False);
// });
// }
[TestCase]
public void VezetElTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
Assert.That(csg.VezetEl(0, 1), Is.False);
csg.UjEl(0, 1, 1.0f);
Assert.Multiple(() =>
{
Assert.That(csg.VezetEl(0, 1), Is.True);
Assert.That(csg.VezetEl(1, 0), Is.False);
});
}
// [TestCase]
// public void SzomszedsagTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 2, 1.0f);
// csg.UjEl(1, 2, 1.0f);
[TestCase]
public void SzomszedsagTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
csg.UjEl(0, 1, 1.0f);
csg.UjEl(0, 2, 1.0f);
csg.UjEl(1, 2, 1.0f);
// Halmaz<int> a_szomszedai = csg.Szomszedai(0);
// Halmaz<int> b_szomszedai = csg.Szomszedai(1);
// Halmaz<int> c_szomszedai = csg.Szomszedai(2);
Halmaz<int> a_szomszedai = csg.Szomszedai(0);
Halmaz<int> b_szomszedai = csg.Szomszedai(1);
Halmaz<int> c_szomszedai = csg.Szomszedai(2);
// Assert.Multiple(() =>
// {
// Assert.That(a_szomszedai.Eleme(0), Is.False);
// Assert.That(a_szomszedai.Eleme(1), Is.True);
// Assert.That(a_szomszedai.Eleme(2), Is.True);
Assert.Multiple(() =>
{
Assert.That(a_szomszedai.Eleme(0), Is.False);
Assert.That(a_szomszedai.Eleme(1), Is.True);
Assert.That(a_szomszedai.Eleme(2), Is.True);
// Assert.That(b_szomszedai.Eleme(0), Is.False);
// Assert.That(b_szomszedai.Eleme(1), Is.False);
// Assert.That(b_szomszedai.Eleme(2), Is.True);
Assert.That(b_szomszedai.Eleme(0), Is.False);
Assert.That(b_szomszedai.Eleme(1), Is.False);
Assert.That(b_szomszedai.Eleme(2), Is.True);
// Assert.That(c_szomszedai.Eleme(0), Is.False);
// Assert.That(c_szomszedai.Eleme(1), Is.False);
// Assert.That(c_szomszedai.Eleme(2), Is.False);
// });
// }
Assert.That(c_szomszedai.Eleme(0), Is.False);
Assert.That(c_szomszedai.Eleme(1), Is.False);
Assert.That(c_szomszedai.Eleme(2), Is.False);
});
}
// [TestCase]
// public void NemLetezoElTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 2, 1.0f);
// Assert.Throws<NincsElKivetel>(() => csg.Suly(1, 0));
// }
[TestCase]
public void NemLetezoElTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
csg.UjEl(0, 1, 1.0f);
csg.UjEl(0, 2, 1.0f);
Assert.Throws<NincsElKivetel>(() => csg.Suly(1, 0));
}
// [TestCase]
// public void ElSulyTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 2.0f);
// csg.UjEl(0, 2, 3.0f);
// float szum = 0.0f;
// csg.Elek.Bejar(x => szum += csg.Suly(x.Honnan, x.Hova));
// Assert.That(szum, Is.EqualTo(5.0f));
// }
// }
[TestCase]
public void ElSulyTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
csg.UjEl(0, 1, 2.0f);
csg.UjEl(0, 2, 3.0f);
float szum = 0.0f;
csg.Elek.Bejar(x => szum += csg.Suly(x.Honnan, x.Hova));
Assert.That(szum, Is.EqualTo(5.0f));
}
}
// [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Gráf Min Feszítőfa Tesztek")]
// public class GrafMinFeszitofaTesztek
// {
// [TestCase]
// public void KisPrimTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 10.0f);
// csg.UjEl(0, 2, 20.0f);
// csg.UjEl(1, 2, 5.0f);
// Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
// Assert.Multiple(() =>
// {
// Assert.That(elek.Kiolvas(1), Is.EqualTo(0));
// Assert.That(elek.Kiolvas(2), Is.EqualTo(1));
// });
// }
[TestFixture(Category = "Adatszerkezetek", TestName = "12 - Gráf Min Feszítőfa Tesztek")]
public class GrafMinFeszitofaTesztek
{
[TestCase]
public void KisPrimTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
csg.UjEl(0, 1, 10.0f);
csg.UjEl(0, 2, 20.0f);
csg.UjEl(1, 2, 5.0f);
Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
Assert.Multiple(() =>
{
Assert.That(elek.Kiolvas(1), Is.EqualTo(0));
Assert.That(elek.Kiolvas(2), Is.EqualTo(1));
});
}
// [TestCase]
// public void NagyPrimTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
// csg.UjEl(0, 1, 5.0f);
// csg.UjEl(0, 3, 4.0f);
[TestCase]
public void NagyPrimTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
csg.UjEl(0, 1, 5.0f);
csg.UjEl(0, 3, 4.0f);
// csg.UjEl(1, 0, 5.0f);
// csg.UjEl(1, 3, 2.0f);
// csg.UjEl(1, 2, 1.0f);
csg.UjEl(1, 0, 5.0f);
csg.UjEl(1, 3, 2.0f);
csg.UjEl(1, 2, 1.0f);
// csg.UjEl(2, 1, 1.0f);
// csg.UjEl(2, 3, 3.0f);
// csg.UjEl(2, 4, 4.0f);
csg.UjEl(2, 1, 1.0f);
csg.UjEl(2, 3, 3.0f);
csg.UjEl(2, 4, 4.0f);
// csg.UjEl(3, 0, 4.0f);
// csg.UjEl(3, 1, 2.0f);
// csg.UjEl(3, 2, 3.0f);
// csg.UjEl(3, 4, 1.0f);
csg.UjEl(3, 0, 4.0f);
csg.UjEl(3, 1, 2.0f);
csg.UjEl(3, 2, 3.0f);
csg.UjEl(3, 4, 1.0f);
// csg.UjEl(4, 2, 4.0f);
// csg.UjEl(4, 3, 1.0f);
csg.UjEl(4, 2, 4.0f);
csg.UjEl(4, 3, 1.0f);
// Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
// float sum = 0.0f;
// csg.Csucsok.Bejar(x =>
// {
// if (x != 0)
// {
// int p = elek.Kiolvas(x);
// sum += csg.Suly(p, x);
// }
// }
// );
// Assert.That(sum, Is.EqualTo(8.0f));
// }
Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
float sum = 0.0f;
csg.Csucsok.Bejar(x =>
{
if (x != 0)
{
int p = elek.Kiolvas(x);
sum += csg.Suly(p, x);
}
}
);
Assert.That(sum, Is.EqualTo(8.0f));
}
// [TestCase]
// public void KisKruskalTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 10.0f);
// csg.UjEl(0, 2, 20.0f);
// csg.UjEl(1, 2, 5.0f);
// Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
// Assert.Multiple(() =>
// {
// Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 10.0f)), Is.True);
// Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 20.0f)), Is.False);
// Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 5.0f)), Is.True);
// });
// }
[TestCase]
public void KisKruskalTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
csg.UjEl(0, 1, 10.0f);
csg.UjEl(0, 2, 20.0f);
csg.UjEl(1, 2, 5.0f);
Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
Assert.Multiple(() =>
{
Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 10.0f)), Is.True);
Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 20.0f)), Is.False);
Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 5.0f)), Is.True);
});
}
// [TestCase]
// public void NagyKruskalTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
// csg.UjEl(0, 1, 5.0f);
// csg.UjEl(0, 3, 4.0f);
[TestCase]
public void NagyKruskalTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
csg.UjEl(0, 1, 5.0f);
csg.UjEl(0, 3, 4.0f);
// csg.UjEl(1, 0, 5.0f);
// csg.UjEl(1, 3, 2.0f);
// csg.UjEl(1, 2, 1.0f);
csg.UjEl(1, 0, 5.0f);
csg.UjEl(1, 3, 2.0f);
csg.UjEl(1, 2, 1.0f);
// csg.UjEl(2, 1, 1.0f);
// csg.UjEl(2, 3, 3.0f);
// csg.UjEl(2, 4, 4.0f);
csg.UjEl(2, 1, 1.0f);
csg.UjEl(2, 3, 3.0f);
csg.UjEl(2, 4, 4.0f);
// csg.UjEl(3, 0, 4.0f);
// csg.UjEl(3, 1, 2.0f);
// csg.UjEl(3, 2, 3.0f);
// csg.UjEl(3, 4, 1.0f);
csg.UjEl(3, 0, 4.0f);
csg.UjEl(3, 1, 2.0f);
csg.UjEl(3, 2, 3.0f);
csg.UjEl(3, 4, 1.0f);
// csg.UjEl(4, 2, 4.0f);
// csg.UjEl(4, 3, 1.0f);
csg.UjEl(4, 2, 4.0f);
csg.UjEl(4, 3, 1.0f);
// Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
// float sum = 0.0f;
// elek.Bejar(x =>
// {
// sum += x.Suly;
// }
// );
// Assert.That(sum, Is.EqualTo(8.0f));
// }
// }
Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
float sum = 0.0f;
elek.Bejar(x =>
{
sum += x.Suly;
}
);
Assert.That(sum, Is.EqualTo(8.0f));
}
}
// [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Gráf Útkeresés Tesztek")]
// public class GrafUtkeresesTesztek
// {
// [TestCase]
// public void DijkstraKicsiGrafTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 10.0f);
// csg.UjEl(0, 2, 20.0f);
// Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 0);
// Assert.Multiple(() =>
// {
// Assert.That(hossz.Kiolvas(0), Is.EqualTo(0.0f));
// Assert.That(hossz.Kiolvas(1), Is.EqualTo(10.0f));
// Assert.That(hossz.Kiolvas(2), Is.EqualTo(20.0f));
// });
[TestFixture(Category = "Adatszerkezetek", TestName = "12 - Gráf Útkeresés Tesztek")]
public class GrafUtkeresesTesztek
{
[TestCase]
public void DijkstraKicsiGrafTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
csg.UjEl(0, 1, 10.0f);
csg.UjEl(0, 2, 20.0f);
Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 0);
Assert.Multiple(() =>
{
Assert.That(hossz.Kiolvas(0), Is.EqualTo(0.0f));
Assert.That(hossz.Kiolvas(1), Is.EqualTo(10.0f));
Assert.That(hossz.Kiolvas(2), Is.EqualTo(20.0f));
});
// csg.UjEl(1, 2, 5.0f);
// hossz = Utkereses.Dijkstra(csg, 0);
// Assert.Multiple(() =>
// {
// Assert.That(hossz.Kiolvas(0), Is.EqualTo(0.0f));
// Assert.That(hossz.Kiolvas(1), Is.EqualTo(10.0f));
// Assert.That(hossz.Kiolvas(2), Is.EqualTo(15.0f));
// });
// }
csg.UjEl(1, 2, 5.0f);
hossz = Utkereses.Dijkstra(csg, 0);
Assert.Multiple(() =>
{
Assert.That(hossz.Kiolvas(0), Is.EqualTo(0.0f));
Assert.That(hossz.Kiolvas(1), Is.EqualTo(10.0f));
Assert.That(hossz.Kiolvas(2), Is.EqualTo(15.0f));
});
}
// [TestCase]
// public void DijkstraJegyzetGrafTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(7);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 3, 2.0f);
// csg.UjEl(0, 4, 4.0f);
[TestCase]
public void DijkstraJegyzetGrafTeszt()
{
CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(7);
csg.UjEl(0, 1, 1.0f);
csg.UjEl(0, 3, 2.0f);
csg.UjEl(0, 4, 4.0f);
// csg.UjEl(1, 0, 1.0f);
// csg.UjEl(1, 3, 2.0f);
// csg.UjEl(1, 2, 9.0f);
csg.UjEl(1, 0, 1.0f);
csg.UjEl(1, 3, 2.0f);
csg.UjEl(1, 2, 9.0f);
// csg.UjEl(2, 1, 9.0f);
// csg.UjEl(2, 3, 5.0f);
// csg.UjEl(2, 5, 1.0f);
csg.UjEl(2, 1, 9.0f);
csg.UjEl(2, 3, 5.0f);
csg.UjEl(2, 5, 1.0f);
// csg.UjEl(3, 0, 2.0f);
// csg.UjEl(3, 1, 2.0f);
// csg.UjEl(3, 2, 5.0f);
// csg.UjEl(3, 5, 3.0f);
csg.UjEl(3, 0, 2.0f);
csg.UjEl(3, 1, 2.0f);
csg.UjEl(3, 2, 5.0f);
csg.UjEl(3, 5, 3.0f);
// csg.UjEl(5, 2, 1.0f);
// csg.UjEl(5, 3, 3.0f);
// csg.UjEl(5, 6, 3.0f);
csg.UjEl(5, 2, 1.0f);
csg.UjEl(5, 3, 3.0f);
csg.UjEl(5, 6, 3.0f);
// csg.UjEl(6, 5, 3.0f);
csg.UjEl(6, 5, 3.0f);
// Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 1);
// Assert.Multiple(() =>
// {
// Assert.That(hossz.Kiolvas(0), Is.EqualTo(1.0f));
// Assert.That(hossz.Kiolvas(1), Is.EqualTo(0.0f));
// Assert.That(hossz.Kiolvas(2), Is.EqualTo(6.0f));
// Assert.That(hossz.Kiolvas(3), Is.EqualTo(2.0f));
// Assert.That(hossz.Kiolvas(4), Is.EqualTo(5.0f));
// Assert.That(hossz.Kiolvas(5), Is.EqualTo(5.0f));
// Assert.That(hossz.Kiolvas(6), Is.EqualTo(8.0f));
// });
// }
// }
//}
Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 1);
Assert.Multiple(() =>
{
Assert.That(hossz.Kiolvas(0), Is.EqualTo(1.0f));
Assert.That(hossz.Kiolvas(1), Is.EqualTo(0.0f));
Assert.That(hossz.Kiolvas(2), Is.EqualTo(6.0f));
Assert.That(hossz.Kiolvas(3), Is.EqualTo(2.0f));
Assert.That(hossz.Kiolvas(4), Is.EqualTo(5.0f));
Assert.That(hossz.Kiolvas(5), Is.EqualTo(5.0f));
Assert.That(hossz.Kiolvas(6), Is.EqualTo(8.0f));
});
}
}
}