Jestem zdezorientowany do dokładnie tak, jak zajęcia dziedziczą metody od siebie. Rozumiem już dziedzictwo z klas bazowych, istnieje jednak pewien kodeks z przykładu, którego nie rozumiem. Obejmuje wyszukiwanie drzewa binarnego i nie mogłem znaleźć żadnych zasobów, które lepiej wyjaśniają, w jaki sposób kod jest dziedziczony.

Moim celem jest zrozumienie tego, aby mógł go również wykorzystać, aby przeszukał listę Linked.

Jeśli ktokolwiek może skierować mnie do jakiejkolwiek odpowiedniej literaturze, która wyjaśnia ten konkretny obszar, byłbym wdzięczny.

Podkreślałem sekcję kodu, której naprawdę nie rozumiem, jak jest poniesione. Specyficzna sekcja jest najpierw opublikowana:

public Company Read(string bezeichnung)
{
    return stri.Search(new Company() { Bezeichnung = bezeichnung });
}

Cały program:

using System;
using System.IO;
using System.Text;
using System.Net;

namespace CompanySearch
{
    class Program
    {
        static void Main(string[] args)
        {
            StreamReader r = new StreamReader(@"C:\Users\chris\Desktop\algo\fuckit\unternehmen.csv", Encoding.Default);
            Companies stri2 = new Companies(r);
            while (true)
            {
                Console.Write("Unternehmensbezeichnung eingeben: ");
                string name = Console.ReadLine();
                if (string.IsNullOrEmpty(name))
                    break;
                //Company konk = stri2.Read(name);
                Company konk = new Company();
                konk = stri2.Read(name);
                if (konk == null)
                    Console.WriteLine("Unternehmen nicht gefunden!");
                else
                    Console.WriteLine(konk + "\n");
            }
        }
    }

    public class Companies
    {
        private BinaryTree<Company> stri = new BinaryTree<Company>();
        public Companies(StreamReader rp)
        {
            // Spaltenüberschriften auslesen
            //var tokens = rp.ReadLine().Split(new char[] { ';' });
            //if (tokens.Length != 3)
            //    throw new ArgumentException("More than 3 columns in company file");
            string line;
            while ((line = rp.ReadLine()) != null)
            {
                var tokens = line.Split(new char[]{';'});
                //tokens = line.Split(new char[] { ';' });
                stri.Add(new Company()
                {Bezeichnung = tokens[0], Branche = tokens[1], Ort = tokens[2]});
            }

            rp.Close();
        }

        public Company Read(string bezeichnung)
        {
            return stri.Search(new Company()
            {Bezeichnung = bezeichnung});
        }
    }

    public class Company : IComparable<Company>
    {
        public string Bezeichnung
        {
            get;
            set;
        }

        public string Branche
        {
            get;
            set;
        }

        public string Ort
        {
            get;
            set;
        }

        public int CompareTo(Company other)
        {
            return Bezeichnung.CompareTo(other.Bezeichnung);
        }

        public override string ToString()
        {
            return string.Format("Bezeichnung: {0}\tBranche: {1}\tOrt: {2}", Bezeichnung, Branche, Ort);
        }
    }

    public enum TraverseModeEnum
    {
        PreOrder,
        PostOrder,
        InOrder,
        ReverseInOrder
    }

    public class BinaryTree<T>
        where T : IComparable<T>
    {
        private sealed class Node<TNode>
            where TNode : IComparable<TNode> // TNode muss IComparable implementieren
        {
            public TNode Item
            {
                get;
                set;
            }

            public Node<TNode> Left
            {
                get;
                set;
            }

            public Node<TNode> Right
            {
                get;
                set;
            }

            public int CompareTo(TNode other)
            {
                return Item.CompareTo(other);
            }
        }

        private Node<T> root;
        public int Count
        {
            get;
            private set;
        }

        public TraverseModeEnum TraverseMode
        {
            get;
            set;
        }

        public BinaryTree()
        {
            TraverseMode = TraverseModeEnum.PreOrder;
        }

        public void Add(T item)
        {
            if (root == null)
                root = new Node<T>()
                {Item = item};
            else
                addTo(root, item);
            Count++;
        }

        public void AddRange(T[] items)
        {
            foreach (var item in items)
                Add(item);
        }

        private void addTo(Node<T> node, T item)
        {
            if (item.CompareTo(node.Item) < 0)
            {
                if (node.Left == null)
                    node.Left = new Node<T>()
                    {Item = item};
                else
                    addTo(node.Left, item);
            }
            else
            {
                if (node.Right == null)
                    node.Right = new Node<T>()
                    {Item = item};
                else
                    addTo(node.Right, item);
            }
        }

        public bool Contains(T item)
        {
            Node<T> node = root;
            while (node != null)
            {
                int c = node.Item.CompareTo(item);
                if (c == 0)
                    return true;
                if (c > 0)
                    node = node.Left;
                else
                    node = node.Right;
            }

            return false;
        }

        public T Search(T item)
        {
            Node<T> node = root;
            while (node != null)
            {
                int c = node.Item.CompareTo(item);
                if (c == 0)
                    return node.Item;
                if (c > 0)
                    node = node.Left;
                else
                    node = node.Right;
            }

            return default (T);
        }

        public void Clear()
        {
            root = null;
            Count = 0;
        }

        public override string ToString()
        {
            string s = "";
            int level = 0;
            traverse(root, level, ref s);
            return s;
        }

        private void traverse(Node<T> node, int level, ref string s)
        {
            if (node == null)
                return;
            bool reverse = TraverseMode == TraverseModeEnum.ReverseInOrder;
            if (TraverseMode == TraverseModeEnum.PreOrder)
                s += "".PadLeft(level, ' ') + node.Item.ToString() + "\n";
            traverse(reverse ? node.Right : node.Left, level + 2, ref s);
            if (TraverseMode == TraverseModeEnum.InOrder || TraverseMode == TraverseModeEnum.ReverseInOrder)
                s += "".PadLeft(level, ' ') + node.Item.ToString() + "\n";
            traverse(reverse ? node.Left : node.Right, level + 2, ref s);
            if (TraverseMode == TraverseModeEnum.PostOrder)
                s += "".PadLeft(level, ' ') + node.Item.ToString() + "\n";
        }
    }
}
0
chris1234 25 luty 2019, 16:20

2 odpowiedzi

Najlepsza odpowiedź

Klasa BinaryTree<T> w kodzie wymaga, aby T musi wdrożyć IComparable<T>. Wiele klas listy-ish tworzy podobne wymagania. Jeśli implementuje typ IComparable<T> oznacza to, że dwa wystąpienia klasy można porównać ze sobą za pomocą metody ComparetTo( T t1, T t2 ). Metoda ta zwraca wskazanie, którego T jest większa niż, mniejsza lub równa drugi. Zdaj sobie sprawę, że większa niż, mniejsza lub równa zależy wyłącznie do typu, który realizuje interfejs. Znajduje się głównie do sortowania lub w inny sposób lokalizowanie rzeczy na drzewie, listy lub innej strukturze na podstawie porównania.

Wdrażanie interfejsu wygląda jak dziedzictwo klasy. Składnia jest taka sama ... ale jest to bardziej jak umowa, ponieważ interfejs nie ma kodu dziedzicznego. Jeśli zrobisz klasę, która idzie jak:

class MyClass: IComparable<MyClass>
{
  //--> stuff
}

... Następnie jesteś zobowiązany do uzyskania metody widocznej z podpisem:

int CompareTo( MyClass a, MyClass b )
{
   //--> look at the two instances and make a determination...
}

Metoda może użyć dowolnych właściwości klasy, aby określić, co sprawia, co sprawia, że a} większa niż, mniejsza lub równa b ... a tym samym kontrolować, jak będzie umieszczony w strukturze.

Klasa może dziedziczyć tylko z jednej innej klasy ... ale może wdrożyć tyle interfejsów, ile potrzebuje. Tak więc zgaduję, wygląda jak wiele dziedzictwa.

1
Clay 25 luty 2019, 14:05

Za. W Twoim kodzie nie ma prawdziwego dziedziczenia. Tylko implementacja standardowego interfejsu, IComparable<T>. Wdrażanie interfejsu jest czasami nazywany dziedziczeniem, ale nie jest to samo. W takim przypadku wymusza Company, aby wdrożyć metodę CompareTo().

B. Kod masz na pytanie o po prostu tworzy obiekt tymczasowy. Możesz go przepisać do czegoś, co może być łatwiejsze do zrozumienia:

//return stri.Search(new Company() { Bezeichnung = bezeichnung });
var tempCompany = new Company() { Bezeichnung = bezeichnung };
return stri.Search(tempCompany);
1
Henk Holterman 25 luty 2019, 13:40