my bad, i think i need to buy again, but thanks..

I'm more familiar with java, so what programs do i need to make this? (ex. netbeans for programming, how about for database, and to make it executble if i use java).

i see, thank you very much, it works now...

it's not working, still giving me the wrong output...

this is my code for my binary tree link

#ifndef BINARYTREELINK_H
#define BINARYTREELINK_H
#include "BinaryTreeNode.h"
#include <iostream>
using namespace std;

class BinaryTree
{
	public:
		BinaryTree();
        void inorderTraversal();
        void preorderTraversal();
        void postorderTraversal();
        void inorder(BinaryTreeNode* p);
        void preorder(BinaryTreeNode* p);
        void postorder(BinaryTreeNode* p);
        void Min();
        void findMin (BinaryTreeNode* p);
        void Max();
        void findMax (BinaryTreeNode* p);
        void deleteNode(const int &deleteint);
        void insert(const int & insertint);
        BinaryTreeNode* deleteFromTree(BinaryTreeNode* p);

   private:
        BinaryTreeNode* root;
};

BinaryTree::BinaryTree()
{
	root = 0;
}

void BinaryTree::inorderTraversal()
{
	inorder(root);
}

void BinaryTree::preorderTraversal()
{
	preorder(root);
}

void BinaryTree::postorderTraversal()
{
	postorder(root);
}

void BinaryTree::inorder(BinaryTreeNode* p)
{
	if(p != 0)
	{
		inorder(p->getLeft());
		cout << p->getData() << " ";
		inorder(p->getRight());
	}
}

void BinaryTree::preorder(BinaryTreeNode* p)
{
	if(p != 0)
	{
		cout << p->getData() << " ";
		preorder(p->getLeft());
		preorder(p->getRight());
	}
}

void BinaryTree::postorder(BinaryTreeNode* p)
{
    if(p != 0)
	{
		postorder(p->getLeft());
		postorder(p->getRight());
		cout << p -> getData() << " ";
	}
}

void BinaryTree::Min()
{
	cout << findMin(root);
}

void BinaryTree::findMin(BinaryTreeNode* p)
{
    if (p != 0)
	{
		findMax(p->getLeft());
        cout << p->getData();
	}
}

void BinaryTree::Max()
{
	findMax(root);
}

void BinaryTree::findMax(BinaryTreeNode* p)
{
    if (p != 0)
	{
		findMax(p->getRight());
        cout << p -> getData();
	}
}

void BinaryTree::deleteNode(const int &deleteint)
{
    BinaryTreeNode* current;

    BinaryTreeNode* trailCurrent;

    bool found = false;

    if(root == NULL)
        cout << "Cannot delete from the empty tree." << endl;
    else
    {
        current = root;
        trailCurrent = root;

        while(current != NULL && !found)
        {
            if(current->getData() == deleteint)
                found = true;
            else
            {
                trailCurrent = current;

                if(deleteint < current->getData())
                    current = current->getLeft();
                else
                    current = current->getRight();
            }
        }

        if(current == NULL)
            cout << "The delete int is not in the list." << endl;
        else
            if(found)
            {
                if(current == root)
                    root = deleteFromTree(root);
                else
                    if(trailCurrent->getData() > deleteint)
                    trailCurrent->setLeft(deleteFromTree(trailCurrent->getLeft()));
                else
                    trailCurrent->setRight(deleteFromTree(trailCurrent->getRight()));
         }
   }
}

void BinaryTree::insert(const int & insertint)
{
    BinaryTreeNode* current;      //reference variable to
                                     //traverse the tree
    BinaryTreeNode* trailCurrent = NULL; //reference variable
                                     //behind current
    BinaryTreeNode* newNode;      //reference variable to
                                     //create the node

    newNode = new BinaryTreeNode();

    newNode->setData(insertint);
    newNode->setLeft(NULL);
    newNode->setRight(NULL);

    if(root == NULL)
        root = newNode;
    else
    {
        current = root;

        while(current != NULL)
        {
            trailCurrent = current;

            if(current->getData() > insertint)
                current = current->getLeft();
            else
                current = current->getRight();
        }

        if(trailCurrent->getData() > insertint)
            trailCurrent->setLeft(newNode);
        else
            trailCurrent->setRight(newNode);
    }
}

BinaryTreeNode* BinaryTree::deleteFromTree(BinaryTreeNode* p)
{
    BinaryTreeNode* current;

    BinaryTreeNode* trailCurrent;

    if(p == NULL)
        cout << "Error: The node to be deleted is null." << endl;
    else if(p->getLeft() == NULL && p->getRight() == NULL)
        p = NULL;
    else if(p->getLeft() == NULL)
        p = p->getRight();
    else if(p->getRight() == NULL)
        p = p->getLeft();
    else
    {
        current = p->getLeft();
        trailCurrent = NULL;

        while(current->getRight() != NULL)
        {
            trailCurrent = current;
            current = current->getRight();
        }

        p->setData(current->getData());

        if(trailCurrent == NULL)
            p->setLeft(current->getLeft());
        else
            trailCurrent->setRight(current->getLeft());
    }

    return p;
}

#endif

jjl, on 12 October 2012 - 09:19 PM, said:

hmm, i think my condition is wrong, the output must be only 1...