static void Main()
{
int[] tab = { 10, 16, 12, 7, 9, 2, 21, 6, 17, 1, 15 };
Drzewo drzewoA = new Drzewo();
for (int i = 0; i < tab.Length; i++)
{
Węzeł w = new Węzeł();
InicjujWęzeł(w, tab[i]);
WstawRekurencyjnie(drzewoA, w);
}
//ZADANIE 7
Console.WriteLine("-------- DRZEWO ---------");
Wypisuj(drzewoA.korzeń, 0);
Console.WriteLine("-------- po obrocie wezla 16 w prawo ---------");
PrawaRotacja(drzewoA.korzeń.prawy);
Wypisuj(drzewoA.korzeń, 0);
Console.WriteLine();
Console.WriteLine("-------- po obrocie wezla w lewo ---------");
LewaRotacja(drzewoA.korzeń.prawy);
Wypisuj(drzewoA.korzeń, 0);
Console.WriteLine("==============");
Console.ReadKey();
}
static Węzeł UtwórzWęzeł(String wartość)
{
Węzeł węzeł = new Węzeł();
węzeł.wartość = wartość;
return(węzeł);
}
static void Main(string[] args)
{
Drzewo drzewo = new Drzewo();
drzewo.korzeń = UtwórzWęzeł("F");
Węzeł wB = UtwórzWęzeł("B");
Węzeł wA = UtwórzWęzeł("A");
Węzeł wC = UtwórzWęzeł("C");
Węzeł wD = UtwórzWęzeł("D");
Węzeł wE = UtwórzWęzeł("E");
Węzeł wG = UtwórzWęzeł("G");
Węzeł wH = UtwórzWęzeł("H");
Węzeł wI = UtwórzWęzeł("I");
DodajLewy(wD, wC);
DodajPrawy(wD, wE);
DodajLewy(wB, wA);
DodajPrawy(wB, wD);
DodajLewy(wI, wH);
DodajPrawy(wG, wI);
DodajLewy(drzewo.korzeń, wB);
DodajPrawy(drzewo.korzeń, wG);
SzukajRodzica(drzewo.korzeń, "E", "");
Console.ReadKey();
}
static void Main()
{
int[] tab = { 10, 16, 12, 7, 9, 2, 21, 6, 17, 1, 15 };
Drzewo drzewoA = new Drzewo();
for (int i = 0; i < tab.Length; i++)
{
Węzeł w = new Węzeł();
InicjujWęzeł(w, tab[i]);
WstawRekurencyjnie(drzewoA, w);
}
Console.WriteLine("====PRZED WSTAWIENIEM====");
Wypisuj(drzewoA.korzeń, 0);
Węzeł nowy = UtwórzWęzeł(14);
WstawJakoKorzeń(ref drzewoA, nowy);
Console.WriteLine("====PO WSTAWIENIU====");
Wypisuj(drzewoA.korzeń, 0);
Console.WriteLine();
Console.ReadLine();
}
static void WstawRekurencyjnie(Węzeł korzeń, Węzeł węzeł)
{
if (korzeń.wartość > węzeł.wartość)
{
if (korzeń.lewy == null)
{
korzeń.lewy = węzeł;
}
else
{
WstawRekurencyjnie(korzeń.lewy, węzeł);
}
}
else
{
if (korzeń.prawy == null)
{
korzeń.prawy = węzeł;
}
else
{
WstawRekurencyjnie(korzeń.prawy, węzeł);
}
}
}
// in-order z wcięciami (odwrotnie)
static void Wypisuj(Węzeł węzeł, int poziom)
{
string wcięcie = "";
int p = poziom;
while (p-- > 0)
{
wcięcie += " ";
}
if (węzeł == null)
{
Console.WriteLine(wcięcie + "*");
}
else
{
if (węzeł.lewy != null || węzeł.prawy != null)
{
Wypisuj((Węzeł)węzeł.prawy, poziom + 3);
}
Console.WriteLine(wcięcie + węzeł.wartość);
if (węzeł.lewy != null || węzeł.prawy != null)
{
Wypisuj((Węzeł)węzeł.lewy, poziom + 3);
}
}
}
public void Sort()
{
Węzeł cur = głowa, index = null;
Klient temp;
if (głowa == null)
{
return;
}
else
{
while (cur != null)
{
index = cur.następny;
while (index != null)
{
if (cur.klient.doZapłaty > index.klient.doZapłaty)
{
temp = cur.klient;
cur.klient = index.klient;
index.klient = temp;
}
index = index.następny;
}
cur = cur.następny;
}
}
}
public void Wyświetl()
{
for (Węzeł tmp = głowa; tmp != null; tmp = tmp.następny)
{
Console.WriteLine(tmp.klient.ZwrocDane());
}
}
public Klient UsuńZOgona()
{
if (ogon == null)
{
throw new Exception("Lista jest pusta");
}
Klient tmp = ogon.klient;
if (głowa == ogon)
{
głowa = ogon = null;
}
else
{
Węzeł wezel;
// w pętli przejdziemy ze zmienną wezel o jeden element przed ogon
for (wezel = głowa; wezel.następny != ogon; wezel = wezel.następny)
{
;
}
// zmienna wezel należy ustawić jako nowy ogon
ogon = wezel;
// i wyczyścić jego następcę
ogon.następny = null;
}
return(tmp);
}
static Węzeł UtwórzWęzeł(String wartość)
{
Węzeł węzeł = new Węzeł();
węzeł.wartość = wartość;
węzeł.dzieci = new List <Węzeł>();
return(węzeł);
}
public void DodajDoGłowy(string imię)
{
Węzeł tmp = new Węzeł();
tmp.imię = imię;
// dodany element staje się głową, więc dotychczasowa głowa staje się obiektem, który jest "następny"
tmp.następny = głowa;
// dodany element staje się głową
głowa = tmp;
}
static int Min(Drzewo d)
{
Węzeł tmp = d.korzeń;
while (tmp.lewy != null)
{
tmp = tmp.lewy;
}
return(tmp.wartość);
}
public int ZwróćRozmiar()
{
int licznik = 0;
for (Węzeł tmp = głowa; tmp != null; tmp = tmp.następny)
{
licznik++;
}
return(licznik);
}
static Węzeł UtwórzWęzeł(int wartość)
{
Węzeł węzeł = new Węzeł();
węzeł.wartość = wartość;
węzeł.prawy = null;
węzeł.lewy = null;
return(węzeł);
}
static void WstawRekurencyjnie(Drzewo drzewo, Węzeł węzeł)
{
if (drzewo.korzeń == null)
{
drzewo.korzeń = węzeł;
}
else
{
WstawRekurencyjnie(drzewo.korzeń, węzeł);
}
}
Węzeł OdczytajWęzeł(StreamReader sr)
{
if (sr.EndOfStream)
{
return(null);
}
else
{
Węzeł odczyt = new Węzeł();
odczyt.imię = sr.ReadLine();
return(odczyt);
}
}
public void Odwróć()
{
// metoda odwracająca kolejność elementów na liście
Węzeł tmp = głowa;
Węzeł tmp2;
while (tmp.następny != null)
{
tmp2 = tmp.następny;
tmp.następny = tmp2.następny;
tmp2.następny = głowa;
głowa = tmp2;
}
}
public void DodajDoGłowy(Klient k)
{
Węzeł tmp = new Węzeł();
tmp.klient = k;
// dodany element staje się głową, więc dotychczasowa głowa staje się obiektem, który jest "następny"
tmp.następny = głowa;
// dodany element staje się głową
głowa = tmp;
// jeśli uprzednio lista była pusta, ogon i głowa wskazują na ten sam element
if (ogon == null)
{
ogon = tmp;
}
}
public int Wyszukaj(string nazwisko)
{
Węzeł tmp = głowa;
int counter = -1;
for (int i = 0; i < ZwróćRozmiar(); i++)
{
if (głowa.klient.nazwisko == nazwisko)
{
counter = i;
}
tmp = tmp.następny;
}
return(counter);
}
public string UsuńZGłowy()
{
string tmp;
if (głowa != null) // sprawdzamy, czy lista nie jest pusta
{
tmp = głowa.imię;
głowa = głowa.następny;
return(tmp);
}
else
{
throw new Exception("Lista pusta!");
}
}
public void DodajDoOgona(Klient k)
{
Węzeł tmp = new Węzeł();
tmp.klient = k;
if (ogon == null)
{
// lista jest pusta, więc ogon ma tę samą wartość, co głowa
ogon = głowa = tmp;
}
else
{
ogon.następny = tmp;
ogon = tmp;
}
}
static void SzukajRodzica(Węzeł węzeł, string wartosc, string rodzic)
{
if (węzeł == null)
{
return;
}
if (wartosc == węzeł.wartość)
{
Console.WriteLine(rodzic);
}
else
{
SzukajRodzica(węzeł.lewy, wartosc, węzeł.wartość);
SzukajRodzica(węzeł.prawy, wartosc, węzeł.wartość);
}
}
static void Main(string[] args)
{
Drzewo drzewo = new Drzewo();
Węzeł korzeń = UtwórzWęzeł("");
string nawiasowe = "(A(B(F)(D(H))(J))(C(G)(E(K))))"; //przykład z wykładu
KonstruujDrzewo(drzewo, korzeń, nawiasowe); //nasz algorytm
//testowo przejde drzewo tylko w lewą stronę
Węzeł test = drzewo.korzeń;
while (true)
{
Console.WriteLine(test.wartość);
if (test.dzieci.Count != 0)
{
test = test.dzieci[0];
}
else
{
break;
}
}
//testowo przejde drzewo tylko w prawą stronę
Console.WriteLine();
test = drzewo.korzeń;
while (true)
{
Console.WriteLine(test.wartość);
if (test.dzieci.Count != 0)
{
test = test.dzieci[test.dzieci.Count - 1];
}
else
{
break;
}
}
Console.ReadKey();
}
public void Zamień(string nazwisko1, string nazwisko2)
{
//Przypdek gdy to ta sama/nierozróżnialna osoba
if (nazwisko1 == nazwisko2)
{
return;
}
Węzeł prevX = null, currX = głowa;
while (currX != null && currX.klient.nazwisko != nazwisko1)
{
prevX = currX;
currX = currX.następny;
}
Węzeł prevY = null, currY = głowa;
while (currY != null && currY.klient.nazwisko != nazwisko2)
{
prevY = currY;
currY = currY.następny;
}
if (currX == null || currY == null)
{
return;
}
if (prevX != null)
{
prevX.następny = currY;
}
else
{
głowa = currY;
}
if (prevY != null)
{
prevY.następny = currX;
}
else
{
głowa = currX;
}
Węzeł temp = currX.następny;
currX.następny = currY.następny;
currY.następny = temp;
}
public int Minimum()
{
Węzeł tmp = głowa;
double min = głowa.klient.doZapłaty;
int indeks = Wyszukaj(głowa.klient.nazwisko);
for (int i = 0; i < ZwróćRozmiar(); i++)
{
tmp = tmp.następny;
if (tmp.klient.doZapłaty < min)
{
min = tmp.klient.doZapłaty;
indeks = Wyszukaj(tmp.klient.nazwisko);
}
}
return(indeks);
}
int Ile(Węzeł węzeł)
{
if (węzeł == null)
{
return(0);
}
int waga = 1;
if (węzeł.lewy != null)
{
waga += Ile(węzeł.lewy);
}
if (węzeł.prawy != null)
{
waga += Ile(węzeł.prawy);
}
return(waga);
}
void CzyZawiera(Węzeł węzeł, int wartość, int wątek)
{
if (węzeł == null)
{
return;
}
if (węzeł.wartość == wartość)
{
if (wątek == 1)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
if (wątek == 2)
{
Console.ForegroundColor = ConsoleColor.Green;
}
if (wątek == 3)
{
Console.ForegroundColor = ConsoleColor.Cyan;
}
if (wątek == 4)
{
Console.ForegroundColor = ConsoleColor.DarkYellow;
}
Console.WriteLine("\tCzytelnik {0}...znalazł {1}.", wątek, wartość);
Console.ForegroundColor = ConsoleColor.Gray;
return;
}
if (wartość < węzeł.wartość)
{
CzyZawiera(węzeł.lewy, wartość, wątek);
}
else
{
CzyZawiera(węzeł.prawy, wartość, wątek);
}
}
static int Następnik(Węzeł korzeń, Węzeł węzeł)
{
if (korzeń.wartość == węzeł.wartość)
{
Drzewo tmp = new Drzewo();
tmp.korzeń = korzeń.prawy;
return(Min(tmp));
}
if (korzeń.wartość > węzeł.wartość)
{
return(Następnik(korzeń.lewy, węzeł));
}
else
{
return(Następnik(korzeń.prawy, węzeł));
}
}
static void PrawaRotacja(Węzeł węzeł)
{
if (węzeł.lewy == null)
{
Console.WriteLine("Nie można zamienić: {0}", węzeł.wartość);
return;
}
Drzewo poddrzewo = new Drzewo();
Węzeł podkorzeń = UtwórzWęzeł(węzeł.wartość);
poddrzewo.korzeń = podkorzeń;
poddrzewo.korzeń.lewy = węzeł.lewy.prawy;
poddrzewo.korzeń.prawy = węzeł.prawy;
węzeł.wartość = węzeł.lewy.wartość;
węzeł.prawy = poddrzewo.korzeń;
węzeł.lewy = węzeł.lewy.lewy;
}
public void Wstaw(Klient k, int indeks)
{
Węzeł temp = new Węzeł();
temp.klient = k;
temp.następny = null;
if (głowa == null)
{
if (indeks != 0)
{
return;
}
else
{
głowa = temp;
}
}
if (głowa != null && indeks == 0)
{
temp.następny = głowa;
głowa = temp;
return;
}
Węzeł cur = głowa;
Węzeł pre = null;
int i = 0;
while (i < indeks)
{
pre = cur;
cur = cur.następny;
if (cur == null)
{
break;
}
i++;
}
temp.następny = cur;
pre.następny = temp;
}
