Perché il codice C ++ mia non riescono a eliminare tutti i nodi nella mia BST?

Stai eliminazione root. E poi il codice sta tentando di accedere alla memoria dove fosse.

Sei così in terra indefinita-comportamento lì.

Non si dovrebbe risolvere il riferimento rootdopo averlo eliminato in deleteNode. Utilizzare un debugger per ispezionare il motivo per cui root->leftnon è nullo.

Siete alla ricerca di root->leftradici dopo aver già eliminato, rendendo avalable per l'utilizzo in un nuovo blocco allocato.

Vorrei semplicemente cambiare l'albero stesso, sarebbe più facile da affrontare allora:

struct Node
{
  Node(data_type data): mLeft(), mRight(), mData(data) {}
  Node(const Node& rhs): mLeft(), mRight(), mData(rhs.mData)
  {
    if (rhs.mLeft.get()) mLeft.reset(new Node(*rhs.mLeft));
    if (rhs.right.get()) mRight.reset(new Node(*rhs.mRight));
  }
  Node& operator=(Node rhs)
  {
    this->swap(rhs);
    return *this;
  }
  ~Node() { }

  void swap(Node& rhs)
  {
    using std::swap;
    swap(mLeft, rhs.mLeft);
    swap(mRight, rhs.mRight);
    swap(mData, rhs.mData);
  }

  Node* left() const { return mLeft.get(); }
  void left(std::auto_ptr<Node> node) { mLeft= node; }

  Node* right() const { return mRight.get(); }
  void right(std::auto_ptr<Node> node) { mRight = node; }

  data_type& data() { return mData; }
  const data_type& data() const { return mData; }

private:
  std::auto_ptr<Node> mLeft;
  std::auto_ptr<Node> mRight;
  data_type mData;
};

Essendo orientato agli oggetti, ogni nodo è ora responsabile per la memoria che gestisce. Inoltre, utilizzando std::auto_ptrl'interfaccia rende chiaro che ci vuole la proprietà.

Si noti che è stato adattato per il deep-copia, qualsiasi altro approccio che richiede boost::shared_ptro equivalente. E sì std::auto_ptrti lascia trattare con la copia da soli, nessuna magia lì.

Questo disegno è molto più pulito rispetto all'utilizzo di una pianura C-structcon tutti di essere in grado di manipolare le risorse. Hai ancora pieno accesso ai dati sottostanti tramite la funzione di accesso ... ma fate attenzione a non invocare un comportamento indefinito ...

Naturalmente, è ancora possibile mandare in crash il basso:

Node& node = ...
delete node.left(); // haha

Ma se C ++ può proteggere contro problemi non intenzionali, lascia la porta aperta per il codice maligno.