బైనరీ ట్రీ లేదా బైనరీ శోధన చెట్టును ఎలా సిద్ధం చేయాలి

పల్లవి

ఈ వ్యాసం బైనరీ శోధన చెట్ల గురించి. నేను ఇటీవల ఒక వ్యాసం చేసాను హఫ్ఫ్మాన్ పద్ధతిని ఉపయోగించి డేటా కుదింపు. అక్కడ నేను బైనరీ చెట్లపై ఎక్కువ శ్రద్ధ చూపలేదు, ఎందుకంటే శోధన, చొప్పించడం మరియు తొలగింపు పద్ధతులు సంబంధితంగా లేవు. ఇప్పుడు నేను చెట్ల గురించి ఒక వ్యాసం రాయాలని నిర్ణయించుకున్నాను. ప్రారంభిద్దాం.

చెట్టు అనేది అంచుల ద్వారా అనుసంధానించబడిన నోడ్‌లతో కూడిన డేటా నిర్మాణం. చెట్టు అనేది గ్రాఫ్ యొక్క ప్రత్యేక సందర్భం అని మనం చెప్పగలం. ఇక్కడ ఒక ఉదాహరణ చెట్టు:

ఇది బైనరీ శోధన చెట్టు కాదు! అంతా కత్తిరించబడింది!

పదజాలం

రూట్

చెట్టు వేరు - ఇది దాని టాప్ నోడ్. ఉదాహరణలో, ఇది నోడ్ A. చెట్టులో, ఒక మార్గం మాత్రమే రూట్ నుండి ఏదైనా ఇతర నోడ్‌కి దారి తీస్తుంది! వాస్తవానికి, ఏదైనా నోడ్‌ని ఈ నోడ్‌కు సంబంధించిన సబ్‌ట్రీ యొక్క రూట్‌గా పరిగణించవచ్చు.

తల్లిదండ్రులు/వారసులు

రూట్ మినహా అన్ని నోడ్‌లు సరిగ్గా ఒక అంచుని మరొక నోడ్‌కు దారితీస్తాయి. ప్రస్తుతము పైన ఉన్న నోడ్ అంటారు తల్లిదండ్రులు ఈ నోడ్. ప్రస్తుతానికి దిగువన ఉన్న మరియు దానికి కనెక్ట్ చేయబడిన నోడ్ అంటారు సంతతి ఈ నోడ్. ఒక ఉదాహరణను ఉపయోగించుకుందాం. నోడ్ B తీసుకుందాం, అప్పుడు దాని పేరెంట్ నోడ్ A అవుతుంది మరియు దాని పిల్లలు D, E మరియు F నోడ్‌లుగా ఉంటాయి.

షీట్

పిల్లలు లేని నోడ్‌ను చెట్టు ఆకు అంటారు. ఉదాహరణలో, ఆకులు D, E, F, G, I, J, K నోడ్లుగా ఉంటాయి.

ఇది ప్రాథమిక పరిభాష. ఇతర భావనలు మరింత చర్చించబడతాయి. కాబట్టి, బైనరీ ట్రీ అనేది ప్రతి నోడ్‌కు ఇద్దరు పిల్లల కంటే ఎక్కువ ఉండని చెట్టు. మీరు ఊహించినట్లుగా, ఉదాహరణ నుండి చెట్టు బైనరీ కాదు, ఎందుకంటే నోడ్స్ B మరియు H ఇద్దరు కంటే ఎక్కువ మంది పిల్లలను కలిగి ఉంటాయి. బైనరీ ట్రీకి ఉదాహరణ ఇక్కడ ఉంది:

చెట్టు నోడ్స్ ఏదైనా సమాచారాన్ని కలిగి ఉండవచ్చు. బైనరీ శోధన చెట్టు క్రింది లక్షణాలను కలిగి ఉన్న బైనరీ చెట్టు:

1. ఎడమ మరియు కుడి సబ్‌ట్రీలు రెండూ బైనరీ శోధన చెట్లు.
2. ఏకపక్ష నోడ్ X యొక్క ఎడమ సబ్‌ట్రీ యొక్క అన్ని నోడ్‌లు నోడ్ X యొక్క డేటా కీ విలువ కంటే తక్కువ డేటా కీ విలువలను కలిగి ఉంటాయి.
3. ఏకపక్ష నోడ్ X యొక్క కుడి సబ్‌ట్రీలోని అన్ని నోడ్‌లు నోడ్ X యొక్క డేటా కీ విలువ కంటే ఎక్కువ లేదా సమానంగా డేటా కీ విలువలను కలిగి ఉంటాయి.

కీ - నోడ్ యొక్క ఏదైనా లక్షణం (ఉదాహరణకు, ఒక సంఖ్య). కీ అవసరం కాబట్టి మీరు ఈ కీకి అనుగుణంగా ఉండే చెట్టు మూలకాన్ని కనుగొనవచ్చు. బైనరీ శోధన చెట్టు యొక్క ఉదాహరణ:

చెట్టు వీక్షణ

మేము అభివృద్ధి చెందుతున్నప్పుడు, మీ అవగాహనను మెరుగుపరచడానికి నేను కొన్ని (బహుశా అసంపూర్ణమైన) కోడ్ ముక్కలను అందిస్తాను. పూర్తి కోడ్ వ్యాసం చివరిలో ఉంటుంది.

ఒక చెట్టు నోడ్లను కలిగి ఉంటుంది. నోడ్ నిర్మాణం:

public class Node<T> {
    private T data;
    private int key;
    private Node<T> leftChild;
    private Node<T> rightChild;

    public Node(T data, int key) {
        this.data = data;
        this.key = key;
    }
    public Node<T> getLeftChild() {
        return leftChild;
    }

    public Node<T> getRightChild() {
        return rightChild;
    }
//...остальные методы узла
}

ప్రతి నోడ్‌కి ఇద్దరు పిల్లలు ఉంటారు (ఎడమ పిల్ల మరియు/లేదా కుడి పిల్లలు శూన్య విలువను కలిగి ఉండే అవకాశం ఉంది). ఈ సందర్భంలో సంఖ్య డేటా నోడ్‌లో నిల్వ చేయబడిన డేటా అని మీరు బహుశా గ్రహించారు; కీ - నోడ్ కీ.

మేము ముడిని క్రమబద్ధీకరించాము, ఇప్పుడు చెట్ల గురించి సమస్యలను నొక్కడం గురించి మాట్లాడుదాం. ఇకపై, "చెట్టు" అనే పదం ద్వారా నేను బైనరీ శోధన చెట్టు యొక్క భావనను సూచిస్తాను. బైనరీ చెట్టు నిర్మాణం:

public class BinaryTree<T> {
     private Node<T> root;

    //методы дерева
}

మాకు ట్రీ యొక్క రూట్ క్లాస్ ఫీల్డ్‌గా మాత్రమే అవసరం, ఎందుకంటే రూట్ నుండి, getLeftChild() మరియు getRightChild() పద్ధతులను ఉపయోగించి, మీరు చెట్టులోని ఏదైనా నోడ్‌ని పొందవచ్చు.

ఒక చెట్టులో అల్గోరిథంలు

Поиск

మీరు నిర్మించిన చెట్టును కలిగి ఉన్నారని అనుకుందాం. కీ కీతో మూలకాన్ని ఎలా కనుగొనాలి? మీరు క్రమానుగతంగా రూట్ నుండి చెట్టు క్రిందికి కదలాలి మరియు తదుపరి నోడ్ యొక్క కీతో కీ విలువను సరిపోల్చాలి: కీ తదుపరి నోడ్ యొక్క కీ కంటే తక్కువగా ఉంటే, నోడ్ యొక్క ఎడమ సంతతికి వెళ్లండి. ఎక్కువ, కుడివైపున, కీలు సమానంగా ఉంటే, కావలసిన నోడ్ కనుగొనబడుతుంది! సంబంధిత కోడ్:

public Node<T> find(int key) {
    Node<T> current = root;
    while (current.getKey() != key) {
        if (key < current.getKey())
            current = current.getLeftChild();
        else
            current = current.getRightChild();
        if (current == null)
            return null;
    }
    return current;
}

కరెంట్ శూన్యంగా మారితే, శోధన చెట్టు చివరకి చేరుకుంది (సంభావిత స్థాయిలో, మీరు చెట్టులో లేని ప్రదేశంలో ఉన్నారు - ఒక ఆకు యొక్క వారసుడు).

సమతుల్య చెట్టుపై శోధన అల్గోరిథం యొక్క ప్రభావాన్ని పరిశీలిద్దాం (నోడ్‌లు ఎక్కువ లేదా తక్కువ సమానంగా పంపిణీ చేయబడిన చెట్టు). అప్పుడు శోధన సామర్థ్యం O(log(n)), మరియు సంవర్గమానం ఆధారం 2. చూడండి: సమతుల్య చెట్టులో n మూలకాలు ఉంటే, దీనర్థం లాగ్ (n) నుండి బేస్ 2 స్థాయిలు ఉంటాయి చెట్టు. మరియు శోధనలో, చక్రం యొక్క ఒక దశలో, మీరు ఒక స్థాయికి దిగువకు వెళ్తారు.

ఇన్సర్ట్

మీరు శోధన యొక్క సారాంశాన్ని గ్రహించినట్లయితే, చొప్పించడాన్ని అర్థం చేసుకోవడం మీకు కష్టం కాదు. మీరు చెట్టు యొక్క ఆకుకి వెళ్లాలి (శోధనలో వివరించిన అవరోహణ నియమాల ప్రకారం) మరియు దాని వారసుడిగా మారాలి - ఎడమ లేదా కుడి, కీని బట్టి. అమలు:

   public void insert(T insertData, int key) {
        Node<T> current = root;
        Node<T> parent;
        Node<T> newNode = new Node<>(insertData, key);
        if (root == null)
            root = newNode;
        else {
            while (true) {
                parent = current;
                if (key < current.getKey()) {
                    current = current.getLeftChild();
                    if (current == null) {
                         parent.setLeftChild(newNode);
                         return;
                    }
                }
                else {
                    current = current.getRightChild();
                    if (current == null) {
                        parent.setRightChild(newNode);
                        return;
                    }
                }
            }
        }
    }

ఈ సందర్భంలో, ప్రస్తుత నోడ్‌తో పాటు, ప్రస్తుత నోడ్ యొక్క పేరెంట్ గురించి సమాచారాన్ని నిల్వ చేయడం అవసరం. కరెంట్ శూన్యానికి సమానంగా మారినప్పుడు, పేరెంట్ వేరియబుల్ మనకు అవసరమైన షీట్‌ను కలిగి ఉంటుంది.
చొప్పించడం యొక్క సామర్థ్యం స్పష్టంగా శోధనకు సమానంగా ఉంటుంది - O(లాగ్(n)).

తొలగింపు

తొలగింపు అనేది చెట్టుపై చేయవలసిన అత్యంత కష్టమైన ఆపరేషన్. ముందుగా మనం తొలగించబోయే మూలకాన్ని కనుగొనవలసి ఉంటుందని స్పష్టమవుతుంది. అయితే అప్పుడు ఏమిటి? మేము దాని సూచనను శూన్యానికి సెట్ చేస్తే, ఈ నోడ్ మూలంగా ఉన్న సబ్‌ట్రీ గురించి సమాచారాన్ని కోల్పోతాము. చెట్ల తొలగింపు పద్ధతులు మూడు కేసులుగా విభజించబడ్డాయి.

మొదటి కేసు. తొలగించబడుతున్న నోడ్‌కు పిల్లలు లేరు

తొలగించబడుతున్న నోడ్‌కు పిల్లలు లేనట్లయితే, అది ఒక ఆకు అని దీని అర్థం. అందువల్ల, మీరు దాని పేరెంట్ యొక్క ఎడమ చైల్డ్ లేదా కుడి చైల్డ్ ఫీల్డ్‌లను శూన్యంగా సెట్ చేయవచ్చు.

రెండవ కేసు. తొలగించాల్సిన నోడ్‌లో ఒక బిడ్డ ఉంది

ఈ కేసు కూడా చాలా క్లిష్టంగా లేదు. మన ఉదాహరణకి తిరిగి వెళ్దాం. మేము కీ 14తో ఒక మూలకాన్ని తొలగించాలని అనుకుందాం. ఇది కీ 10తో ఉన్న నోడ్ యొక్క సరైన వారసుడు కాబట్టి, దాని వారసులలో ఎవరైనా (ఈ సందర్భంలో సరైనది) 10 కంటే ఎక్కువ కీని కలిగి ఉంటారని అంగీకరిస్తున్నారు, కాబట్టి మీరు చెట్టు నుండి దానిని సులభంగా "కత్తిరించవచ్చు" మరియు తొలగించబడుతున్న నోడ్ యొక్క బిడ్డకు తల్లిదండ్రులను నేరుగా కనెక్ట్ చేయవచ్చు, అనగా. కీ 10తో నోడ్‌ని నోడ్ 13కి కనెక్ట్ చేయండి. దాని పేరెంట్‌కి ఎడమవైపు ఉన్న నోడ్‌ని తొలగించాల్సిన అవసరం ఉన్నట్లయితే పరిస్థితి ఇలాగే ఉంటుంది. దాని గురించి మీరే ఆలోచించండి - ఖచ్చితమైన సారూప్యత.

మూడవ కేసు. ఒక నోడ్‌కి ఇద్దరు పిల్లలు ఉన్నారు

అత్యంత క్లిష్టమైన కేసు. ఒక కొత్త ఉదాహరణ చూద్దాం.

వారసుడి కోసం వెతకండి

కీ 25తో నోడ్‌ని తొలగించాలని అనుకుందాం. దాని స్థానంలో ఎవరిని ఉంచాలి? అతని అనుచరులలో ఒకరు (వారసులు లేదా వారసుల వారసులు) అవ్వాలి వారసుడు(తొలగించబడుతున్న నోడ్ యొక్క స్థానాన్ని తీసుకునే వ్యక్తి).

వారసుడు ఎవరు కావాలో అర్థం చేసుకోవడం ఎలా? అకారణంగా, ఇది ట్రీలోని నోడ్, దీని కీ తొలగించబడిన నోడ్ నుండి తదుపరి అతిపెద్దది. అల్గోరిథం క్రింది విధంగా ఉంది. మీరు దాని కుడి వారసుడి వద్దకు వెళ్లాలి (ఎల్లప్పుడూ కుడి వైపుకు, ఎందుకంటే తొలగించబడిన నోడ్ కీ కంటే సక్సెసర్ కీ ఎక్కువ అని ఇప్పటికే చెప్పబడింది), ఆపై ఈ కుడి వారసుడి యొక్క ఎడమ వారసుల గొలుసు ద్వారా వెళ్లండి. . ఉదాహరణలో, మేము కీ 35 తో నోడ్‌కి వెళ్తాము, ఆపై దాని ఎడమ పిల్లల గొలుసు ద్వారా లీఫ్‌కి వెళ్తాము - ఈ సందర్భంలో, ఈ గొలుసు కీ 30 ఉన్న నోడ్‌ను మాత్రమే కలిగి ఉంటుంది. ఖచ్చితంగా చెప్పాలంటే, మేము చూస్తున్నాము. మేము నోడ్ కోసం వెతుకుతున్న దాని కంటే పెద్ద నోడ్‌ల సెట్‌లోని చిన్న నోడ్ కోసం.

తదుపరి శోధన పద్ధతి కోడ్:

    public Node<T> getSuccessor(Node<T> deleteNode) {
        Node<T> parentSuccessor = deleteNode;//родитель преемника
        Node<T> successor = deleteNode;//преемник
        Node<T> current = successor.getRightChild();//просто "пробегающий" узел
        while (current != null) {
            parentSuccessor = successor;
            successor = current;
            current = current.getLeftChild();
        }
        //на выходе из цикла имеем преемника и родителя преемника
        if (successor != deleteNode.getRightChild()) {//если преемник не совпадает с правым потомком удаляемого узла
            parentSuccessor.setLeftChild(successor.getRightChild());//то его родитель забирает себе потомка преемника, чтобы не потерять его
            successor.setRightChild(deleteNode.getRightChild());//связываем преемника с правым потомком удаляемого узла
        }
        return successor;
    }

తొలగింపు పద్ధతి కోసం పూర్తి కోడ్:

public boolean delete(int deleteKey) {
        Node<T> current = root;
        Node<T> parent = current;
        boolean isLeftChild = false;//В зависимости от того, является ли  удаляемый узел левым или правым потомком своего родителя, булевская переменная isLeftChild будет принимать значение true или false соответственно.
        while (current.getKey() != deleteKey) {
            parent = current;
            if (deleteKey < current.getKey()) {
                current = current.getLeftChild();
                isLeftChild = true;
            } else {
                isLeftChild = false;
                current = current.getRightChild();
            }
            if (current == null)
                return false;
        }

        if (current.getLeftChild() == null && current.getRightChild() == null) {//первый случай
            if (current == root)
                current = null;
            else if (isLeftChild)
                parent.setLeftChild(null);
            else
                parent.setRightChild(null);
        }
        else if (current.getRightChild() == null) {//второй случай
            if (current == root)
                root = current.getLeftChild();
            else if (isLeftChild)
                parent.setLeftChild(current.getLeftChild());
            else
                current.setRightChild(current.getLeftChild());
        } else if (current.getLeftChild() == null) {
            if (current == root)
                root = current.getRightChild();
            else if (isLeftChild)
                parent.setLeftChild(current.getRightChild());
            else
                parent.setRightChild(current.getRightChild());
        } 
        else {//третий случай
            Node<T> successor = getSuccessor(current);
            if (current == root)
                root = successor;
            else if (isLeftChild)
                parent.setLeftChild(successor);
            else
                parent.setRightChild(successor);
        }
        return true;
    }

సంక్లిష్టతను O(log(n))కి అంచనా వేయవచ్చు.

చెట్టులో గరిష్ట/కనిష్టాన్ని కనుగొనడం

చెట్టులో కనిష్ట/గరిష్ట విలువను ఎలా కనుగొనాలో స్పష్టంగా ఉంది - మీరు వరుసగా చెట్టు యొక్క ఎడమ/కుడి మూలకాల గొలుసు వెంట వరుసగా కదలాలి; మీరు షీట్‌కి చేరుకున్నప్పుడు, అది కనిష్ట/గరిష్ట మూలకం అవుతుంది.

    public Node<T> getMinimum(Node<T> startPoint) {
        Node<T> current = startPoint;
        Node<T> parent = current;
        while (current != null) {
            parent = current;
            current = current.getLeftChild();
        }
        return parent;
    }

    public Node<T> getMaximum(Node<T> startPoint) {
        Node<T> current = startPoint;
        Node<T> parent = current;
        while (current != null) {
            parent = current;
            current = current.getRightChild();
        }
        return parent;
    }

సంక్లిష్టత - O(log(n))

సుష్ట బైపాస్

ట్రావెర్సల్ చెట్టు యొక్క ప్రతి నోడ్‌ను సందర్శిస్తుంది, దానితో కొంత చర్యను చేస్తుంది.

రికర్సివ్ సిమెట్రిక్ ట్రావర్సల్ అల్గోరిథం:

1. ఎడమ బిడ్డపై చర్య చేయండి
2. మీతో ఒక చర్య చేయండి
3. సరైన పిల్లలపై చర్య తీసుకోండి

కోడ్:

    public void inOrder(Node<T> current) {
        if (current != null) {
            inOrder(current.getLeftChild());
            System.out.println(current.getData() + " ");//Здесь может быть все, что угодно
            inOrder(current.getRightChild());
        }
    }

తీర్మానం

చివరగా! నేను ఏమీ వివరించనట్లయితే లేదా ఏవైనా వ్యాఖ్యలు ఉంటే, దయచేసి వాటిని వ్యాఖ్యలలో ఉంచండి. వాగ్దానం చేసినట్లుగా, నేను పూర్తి కోడ్‌ను అందిస్తాను.

Node.java:

public class Node<T> {
    private T data;
    private int key;
    private Node<T> leftChild;
    private Node<T> rightChild;

    public Node(T data, int key) {
        this.data = data;
        this.key = key;
    }

    public void setLeftChild(Node<T> newNode) {
        leftChild = newNode;
    }

    public void setRightChild(Node<T> newNode) {
        rightChild = newNode;
    }

    public Node<T> getLeftChild() {
        return leftChild;
    }

    public Node<T> getRightChild() {
        return rightChild;
    }

    public T getData() {
        return data;
    }

    public int getKey() {
        return key;
    }
}

BinaryTree.java:

public class BinaryTree<T> {
    private Node<T> root;

    public Node<T> find(int key) {
        Node<T> current = root;
        while (current.getKey() != key) {
            if (key < current.getKey())
                current = current.getLeftChild();
            else
                current = current.getRightChild();
            if (current == null)
                return null;
        }
        return current;
    }

    public void insert(T insertData, int key) {
        Node<T> current = root;
        Node<T> parent;
        Node<T> newNode = new Node<>(insertData, key);
        if (root == null)
            root = newNode;
        else {
            while (true) {
                parent = current;
                if (key < current.getKey()) {
                    current = current.getLeftChild();
                    if (current == null) {
                         parent.setLeftChild(newNode);
                         return;
                    }
                }
                else {
                    current = current.getRightChild();
                    if (current == null) {
                        parent.setRightChild(newNode);
                        return;
                    }
                }
            }
        }
    }

    public Node<T> getMinimum(Node<T> startPoint) {
        Node<T> current = startPoint;
        Node<T> parent = current;
        while (current != null) {
            parent = current;
            current = current.getLeftChild();
        }
        return parent;
    }

    public Node<T> getMaximum(Node<T> startPoint) {
        Node<T> current = startPoint;
        Node<T> parent = current;
        while (current != null) {
            parent = current;
            current = current.getRightChild();
        }
        return parent;
    }

    public Node<T> getSuccessor(Node<T> deleteNode) {
        Node<T> parentSuccessor = deleteNode;
        Node<T> successor = deleteNode;
        Node<T> current = successor.getRightChild();
        while (current != null) {
            parentSuccessor = successor;
            successor = current;
            current = current.getLeftChild();
        }

        if (successor != deleteNode.getRightChild()) {
            parentSuccessor.setLeftChild(successor.getRightChild());
            successor.setRightChild(deleteNode.getRightChild());
        }
        return successor;
    }

    public boolean delete(int deleteKey) {
        Node<T> current = root;
        Node<T> parent = current;
        boolean isLeftChild = false;
        while (current.getKey() != deleteKey) {
            parent = current;
            if (deleteKey < current.getKey()) {
                current = current.getLeftChild();
                isLeftChild = true;
            } else {
                isLeftChild = false;
                current = current.getRightChild();
            }
            if (current == null)
                return false;
        }

        if (current.getLeftChild() == null && current.getRightChild() == null) {
            if (current == root)
                current = null;
            else if (isLeftChild)
                parent.setLeftChild(null);
            else
                parent.setRightChild(null);
        }
        else if (current.getRightChild() == null) {
            if (current == root)
                root = current.getLeftChild();
            else if (isLeftChild)
                parent.setLeftChild(current.getLeftChild());
            else
                current.setRightChild(current.getLeftChild());
        } else if (current.getLeftChild() == null) {
            if (current == root)
                root = current.getRightChild();
            else if (isLeftChild)
                parent.setLeftChild(current.getRightChild());
            else
                parent.setRightChild(current.getRightChild());
        } 
        else {
            Node<T> successor = getSuccessor(current);
            if (current == root)
                root = successor;
            else if (isLeftChild)
                parent.setLeftChild(successor);
            else
                parent.setRightChild(successor);
        }
        return true;
    }

    public void inOrder(Node<T> current) {
        if (current != null) {
            inOrder(current.getLeftChild());
            System.out.println(current.getData() + " ");
            inOrder(current.getRightChild());
        }
    }
}

PS

O(n)కి క్షీణత

మీలో చాలామంది గమనించి ఉండవచ్చు: మీరు చెట్టును అసమతుల్యతగా చేస్తే ఏమి చేయాలి? ఉదాహరణకు, చెట్టులో పెరుగుతున్న కీలతో నోడ్‌లను ఉంచండి: 1,2,3,4,5,6... అప్పుడు చెట్టు కొంతవరకు లింక్ చేయబడిన జాబితాను పోలి ఉంటుంది. మరియు అవును, చెట్టు దాని చెట్టు నిర్మాణాన్ని కోల్పోతుంది మరియు అందువల్ల డేటా యాక్సెస్ సామర్థ్యాన్ని కోల్పోతుంది. శోధన, చొప్పించడం మరియు తొలగింపు కార్యకలాపాల సంక్లిష్టత లింక్ చేయబడిన జాబితా వలె ఉంటుంది: O(n). ఇది చాలా ముఖ్యమైనది, నా అభిప్రాయం ప్రకారం, బైనరీ చెట్ల యొక్క ప్రతికూలతలు.

నమోదు చేసుకున్న వినియోగదారులు మాత్రమే సర్వేలో పాల్గొనగలరు. సైన్ ఇన్ చేయండిదయచేసి.

నేను చాలా కాలంగా హబ్‌లో లేను మరియు మీరు ఏ అంశాలపై ఎక్కువ కథనాలను చూడాలనుకుంటున్నారో నేను తెలుసుకోవాలనుకుంటున్నాను?

• డేటా నిర్మాణాలు

• అల్గారిథమ్‌లు (DP, రికర్షన్, డేటా కంప్రెషన్ మొదలైనవి)

• నిజ జీవితంలో డేటా నిర్మాణాలు మరియు అల్గారిథమ్‌ల అప్లికేషన్

• జావాలో ప్రోగ్రామింగ్ Android అప్లికేషన్లు

• జావాలో ప్రోగ్రామింగ్ వెబ్ అప్లికేషన్లు

2 వినియోగదారులు ఓటు వేశారు. 1 వినియోగదారు దూరంగా ఉన్నారు.

మూలం: www.habr.com