GIDForums

Go Back   GIDForums > Computer Programming Forums > CPP / C++ Forum
Reload this Page 20 questions game
User Name
Password
Register FAQ Members List Calendar Search Today's Posts Mark Forums Read


 
 
Thread Tools Search this Thread Rate Thread
  #1  
Old 15-Mar-2008, 21:16
monkeeass83 monkeeass83 is offline
New Member
  
Join Date: Feb 2008
Posts: 13
monkeeass83 is on a distinguished road

20 questions game

I am working on a project to create an expert system decision tree to play a 20 questions game. I must implement it with a binary tree with the user answers only being yes or no. Does anyone know how to build this decision tree. I have started on this, but have hit a dead end, so I don't have any code to put up. Does this require some type of loop? Thank you for any input you may be able to give.
  #2  
Old 21-Mar-2008, 03:32
Peter_APIIT Peter_APIIT is offline
Regular Member
  
Join Date: May 2007
Location: Malaysia
Posts: 353
Peter_APIIT is on a distinguished road

Re: 20 questions game

u started this project, you need grasp the understanding of binary tree.

BY the way, this is my C code :

CPP / C++ / C Code:
#ifndef _BST_
#define _BST_
 
struct Tree_Node 
{
    int value;
    struct Tree_Node *leftNode;
    struct Tree_Node *rightNode;
};
 
struct BST
{
    struct Tree_Node *root;
};

// -----------------Tree Node Function---------------------------
struct Tree_Node* Tree_Node_Allocate(struct Tree_Node *);
void Tree_Node_Deallocate(struct Tree_Node *);
 
struct Tree_Node* Tree_Node_Initialize(struct Tree_Node *, int *);
 
struct Tree_Node* Searching(struct BST *, int *);
struct Tree_Node* RecursiveSearch(struct Tree_Node *, int *, ...);
struct Tree_Node* RecursiveMinSearch(struct Tree_Node *);
struct Tree_Node* RecursiveMaxSearch(struct Tree_Node *);

// --------------------------------------------------------------

// ------------------BST Tree Function---------------------------
struct BST* BST_Allocate(struct BST *);
void BST_Deallocate(struct BST *);
 
struct BST* BST_Insert(struct BST *, struct Tree_Node *);
struct BST* BST_Remove(struct BST *,int *); 

void FindMin(struct BST *);
void FindMax(struct BST *);
void MinHeight(int *);
void MaxHeight(int *);

void BST_UserInput(int *);
int* QuerySearchValue(int *);
int* numberTreeNodes(int *);
int* removeNode(int *);

// Root->Left->Right
/*
	If left node has children, traversal down until left
	has no children
	Or called Depth-First Traversal(DFS)
*/
void PreorderDisplay(struct BST *);  
void RecursivePreorderDisplay(struct Tree_Node *);

// Left->Root->Right
void InorderDisplay(struct BST *);
void RecursiveInorderDisplay(struct Tree_Node *);

// Left->Right->Root
void PostorderDisplay(struct BST *);
void RecursivePostorderDisplay(struct Tree_Node *);
/*
	Breadth-first traversal(BFS) - traversal from level 0 
	until lowest level
*/
void RecursivePostOrder_Deallocate(struct Tree_Node *);
void SearchDisplay(struct Tree_Node *, int *);

// --------------------------------------------------------------

#endif
/*
	Binary Search Tree can be used for efficient searching, 
	arithmetic expression parsing, and 
	data compression

	Fullness - Previous Level * 2 = Current Level is 
			   consider fullness
	Balance - isBalanced() - Find Maximum height
	          of left node and right node
			  if == balanced else unbalaced
			  All node must same height then 
			  considered balanced
	Leftness - 

    Recursion good for keeping track of paths(Fixed Path or a route)

	AVL Tree - Tree that help balancing when inserted
	Splay Tree - Move data that frequent accessed to
				 the top of tree
    Heap - Another sorted tree structure used maily
	       in priority queue
	Huffman Tree - Used for data compression
    
*/




#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
 
#include "BST.h"
// --------------------------------------------------------------
/*
	Interpolation Search
	[url]http://www.brpreiss.com/books/opus4/html/page9.html[/url]
	[url]http://www.ccs.neu.edu/home/vkp/csu213-sp05/Assignments/Assignment5/[/url]
*/

// --------------------------------------------------------------
int main(int argc, char *argv[])
{
	struct BST *BST = 0;
	struct Tree_Node *Tree_Node = 0, *resultSearched=0;
	
	int number, search = 0, *numberptr, *searchptr,
		numberNodes, removeSpecificNode, 
		*numberNodesptr, *removeptr;

	numberptr = &number;
	searchptr = &search;
	numberNodesptr = &numberNodes;
	removeptr = &removeSpecificNode;

	BST = BST_Allocate(BST);
	

	Tree_Node = Tree_Node_Allocate(Tree_Node);
	BST_UserInput(numberptr);
	Tree_Node = Tree_Node_Initialize(Tree_Node, numberptr);
	BST = BST_Insert(BST, Tree_Node);

	Tree_Node = Tree_Node_Allocate(Tree_Node);
	BST_UserInput(numberptr);
	Tree_Node = Tree_Node_Initialize(Tree_Node, numberptr);
	BST = BST_Insert(BST, Tree_Node);

	Tree_Node = Tree_Node_Allocate(Tree_Node);
	BST_UserInput(numberptr);
	Tree_Node = Tree_Node_Initialize(Tree_Node, numberptr);
	BST = BST_Insert(BST, Tree_Node);

	Tree_Node = Tree_Node_Allocate(Tree_Node);
	BST_UserInput(numberptr);
	Tree_Node = Tree_Node_Initialize(Tree_Node, numberptr);
	BST = BST_Insert(BST, Tree_Node);

	Tree_Node = Tree_Node_Allocate(Tree_Node);
	BST_UserInput(numberptr);
	Tree_Node = Tree_Node_Initialize(Tree_Node, numberptr);
	BST = BST_Insert(BST, Tree_Node);

	Tree_Node = Tree_Node_Allocate(Tree_Node);
	BST_UserInput(numberptr);
	Tree_Node = Tree_Node_Initialize(Tree_Node, numberptr);
	BST = BST_Insert(BST, Tree_Node);

	Tree_Node = Tree_Node_Allocate(Tree_Node);
	BST_UserInput(numberptr);
	Tree_Node = Tree_Node_Initialize(Tree_Node, numberptr);
	BST = BST_Insert(BST, Tree_Node);

	InorderDisplay(BST);

	PreorderDisplay(BST);

	PostorderDisplay(BST);

	searchptr = QuerySearchValue(searchptr);
	resultSearched = Searching(BST, searchptr);
	SearchDisplay(resultSearched, searchptr);

	FindMin(BST);
	FindMax(BST);
/*
	numberNodesptr = numberTreeNodes(numberNodesptr);
	MinHeight(numberNodesptr);
	MaxHeight(numberNodesptr);
*/
	removeptr = removeNode(removeptr);
	BST = BST_Remove(BST, removeptr);
	PreorderDisplay(BST);

	removeptr = removeNode(removeptr);
	BST = BST_Remove(BST, removeptr);
	PreorderDisplay(BST);


	BST_Deallocate(BST);
	

	return 0;
}
// ------------------------------------------------------------
struct BST* BST_Allocate(struct BST *BST)
{
    BST = malloc(sizeof(struct BST));
    assert(BST != 0);
    BST->root = NULL;
 
    return BST;
}
// -----------------------------------------------------------
void BST_Deallocate(struct BST *BST)
{
	// Memory Leak if i only delete root and not
    // all tree nodes request from heap memory
	/*
		Use postorder traversal method to free Tree Node
		and finally root
	*/

    if (BST != NULL && BST->root != NULL)
    {
		RecursivePostOrder_Deallocate(BST->root);
        free(BST);
        BST->root = NULL;
		BST = BST;
    }
    else
    {
        exit(0);
    }
}
// --------------------------------------------------------
void RecursivePostOrder_Deallocate(struct Tree_Node *Tree_Node)
{
	if (Tree_Node != NULL)
	{
		RecursivePostOrder_Deallocate(Tree_Node->leftNode);
		RecursivePostOrder_Deallocate(Tree_Node->rightNode);
		free(Tree_Node);
	}
}
// ---------------------------------------------------------
struct BST* BST_Insert(struct BST *BST, struct Tree_Node *Tree_Node)
{
	struct Tree_Node *traversal;
	int *numberptr, number;

	numberptr = &number;

	traversal = BST->root;

	*numberptr = Tree_Node->value;

	if (BST->root == NULL)
	{
		BST->root = Tree_Node;
	}
	else
	{
		if (BST->root->leftNode == NULL 
			|| BST->root->rightNode == NULL)
		{
			if (Tree_Node->value < BST->root->value)
			{
				BST->root->leftNode = Tree_Node;
			}
			else
			{
				BST->root->rightNode = Tree_Node;
			}
		}
		else
		{
			traversal = Searching(BST, numberptr);
			if (*numberptr < traversal->value)
			{
				traversal->leftNode = Tree_Node;
			}
			else
			{
				traversal->rightNode = Tree_Node;
			}
		}
	}
	/*
		Top Down construction - Create root first
		Bottom Up construction - Create child first
	*/
	return BST;
}
// -------------------------------------------------------
struct BST* BST_Remove(struct BST *BST,int *removeptr)
{
	// Parent of RemoveNode
	struct Tree_Node *parent;      
	// Parent of traversal 
	struct Tree_Node *parent_traversal; 
	struct Tree_Node *tempTraversal;
	struct Tree_Node *traversal;    
	struct Tree_Node *RemoveNode;  
	// To maintain children of RemoveNode
	struct Tree_Node *tempRemoveNode;  

	char special = 'y';

	parent = BST->root;
	traversal = BST->root;
	tempTraversal = BST->root;
	parent_traversal = BST->root;

	/*
		if no child, just delete
		if one child, point by grandparent
		
		if two children, 
		swap with it with 
		inorder-successor(Left child of right sub Tree)	
		// Smallest in right sub tree
		Traverse once to right , then continue
		traverse to left  
		
		or
		inorder-predecessor(Right child of Left sub Tree)
		// Largest in left sub tree
	*/
	
	// Iteractve Remove Tree Node
	while(traversal != NULL)
	{
		// To remove root node
		if (*removeptr == tempTraversal->value)
		{
			RemoveNode = BST->root;
			tempRemoveNode = BST->root;
			
			// got 2 children
			if (RemoveNode->leftNode != NULL
						&& RemoveNode->rightNode != NULL)
			{
				// Traverse once to right tree 
				if (tempTraversal->rightNode != NULL)
				{
					tempTraversal = tempTraversal->rightNode;
				}

				// Continue traverse smallest unit left sub tree
				while(tempTraversal->leftNode != NULL)
				{
					tempTraversal = tempTraversal->leftNode;
				}
				tempRemoveNode->leftNode = RemoveNode->leftNode;
				tempRemoveNode->rightNode = RemoveNode->rightNode;

				tempTraversal->leftNode = tempRemoveNode->leftNode;
				tempTraversal->rightNode = tempRemoveNode->rightNode;

				if (traversal != NULL)
				{
					traversal = traversal->rightNode;
				}

				traversal->leftNode = NULL;
				Tree_Node_Deallocate(RemoveNode);

				BST->root = tempTraversal;

				while(traversal != NULL)
				{
					traversal = traversal->leftNode;
				}
			}		
		}
		else if (traversal != NULL)
		{
			if (*removeptr < traversal->value)
			{
				traversal = traversal->leftNode;
				parent_traversal = parent_traversal->leftNode;

				if (traversal != NULL)
				{
					RemoveNode = traversal;
					tempRemoveNode = traversal;
				}

				if (traversal != NULL)
				{
					if (traversal->value == *removeptr)
					{
						// got 2 children
						if (RemoveNode->leftNode != NULL
							&& RemoveNode->rightNode != NULL)
						{
							// Traverse once to right tree 
							if (traversal->rightNode != NULL)
							{
								traversal = traversal->rightNode;
								parent_traversal = parent_traversal->rightNode;
							}

							// Continue traverse smallest unit left sub tree
							while(traversal->leftNode != NULL)
							{
								traversal = traversal->leftNode;
							}

							// To identify parent of traversal
							if (parent_traversal->leftNode != NULL)
							{
								while(parent_traversal->leftNode->leftNode != NULL)
								{	
									parent_traversal = parent_traversal->leftNode;
								}
								special = 'n';
							}

							if (special == 'n')
							{
								tempRemoveNode->rightNode = RemoveNode->rightNode;
								tempRemoveNode->leftNode = RemoveNode->leftNode;
							}
							
							if (traversal->value 
								<parent->value)
							{
								parent->leftNode = traversal;
							}
							else
							{
								parent->rightNode = traversal;
							}

							if (special == 'n')
							{
								traversal->leftNode = tempRemoveNode->leftNode;
								traversal->rightNode = tempRemoveNode->rightNode;

								if (RemoveNode->value 
									< parent_traversal->value)
								{
									parent_traversal->leftNode = RemoveNode;
								}
								else
								{
									parent_traversal->rightNode = RemoveNode;
								}
							}
							else
							{
								traversal->leftNode = tempRemoveNode->leftNode;
							}
							Tree_Node_Deallocate(RemoveNode);
						}
						// Got 1 child
						else if (RemoveNode->leftNode != NULL
							|| RemoveNode->rightNode != NULL)
						{
							// Swap it with its Left child 
							if (RemoveNode->leftNode != NULL)
							{
								traversal = traversal->leftNode;
								
								if (traversal->value < parent->value)
								{
									parent->leftNode = traversal;
								}
								else
								{
									parent->rightNode = traversal;
								}
								Tree_Node_Deallocate(RemoveNode);
							}

							// Swap it with its Right child 
							if (RemoveNode->rightNode != NULL)
							{
								traversal = traversal->rightNode;

								if (traversal->value < parent->value)
								{
									parent->leftNode = traversal;
								}
								else
								{
									parent->rightNode = traversal;
								}
								Tree_Node_Deallocate(RemoveNode);
							}
						}
						// No child
						else
						{
							Tree_Node_Deallocate(RemoveNode);
							parent->leftNode = NULL;
						}
					}
				}
				if (parent != NULL)
				{
					parent = parent->leftNode;
				}	
			}
			else
			{
				traversal = traversal->rightNode;
				parent_traversal = parent_traversal->rightNode;
				
				if (traversal != NULL)
				{
					RemoveNode = traversal;
					tempRemoveNode = traversal;
				}

				if (traversal != NULL)
				{
					if (traversal->value == *removeptr)
					{
						// got 2 children
						if (RemoveNode->leftNode != NULL
							&& RemoveNode->rightNode != NULL)
						{
							// Traverse once to right tree 
							if (traversal->rightNode != NULL)
							{
								traversal = traversal->rightNode;
								parent_traversal = parent_traversal->rightNode;
							}

							// Continue traverse smallest unit left sub tree
							while(traversal->leftNode != NULL)
							{
								traversal = traversal->leftNode;
							}

							parent_traversal = parent_traversal;
							// To identify parent of traversal
							if (parent_traversal->leftNode != NULL)
							{
								while(parent_traversal->leftNode->leftNode != NULL)
								{
									parent_traversal = parent_traversal->leftNode;
								}
								special = 'n';
							}

							tempRemoveNode->leftNode = RemoveNode->leftNode;
							tempRemoveNode->rightNode = RemoveNode->rightNode;
							
							if (traversal->value 
								<parent->value)
							{
								parent->leftNode = traversal;
							}
							else
							{
								parent->rightNode = traversal;
							}
							
							if (special == 'n')
							{
								traversal->leftNode = tempRemoveNode->leftNode;
								traversal->rightNode = tempRemoveNode->rightNode;
						
								if (RemoveNode->value 
									< parent_traversal->value)
								{
									parent_traversal->leftNode = RemoveNode;
								}
								else
								{
									parent_traversal->rightNode = RemoveNode;
								}
							}
							else
							{
								traversal->leftNode = tempRemoveNode->leftNode;
							}
							Tree_Node_Deallocate(RemoveNode);
						}
						// Got 1 child
						else if (RemoveNode->leftNode != NULL
							|| RemoveNode->rightNode != NULL)
						{
							// Swap it with its Left child 
							if (RemoveNode->leftNode != NULL)
							{
								traversal = traversal->leftNode;
								
								if (traversal->value < parent->value)
								{
									parent->leftNode = traversal;
								}
								else
								{
									parent->rightNode = traversal;
								}
								Tree_Node_Deallocate(RemoveNode);
							}

							// Swap it with its Right child 
							if (RemoveNode->rightNode != NULL)
							{
								traversal = traversal->rightNode;

								if (traversal->value < parent->value)
								{
									parent->leftNode = traversal;
								}
								else
								{
									parent->rightNode = traversal;
								}
								Tree_Node_Deallocate(RemoveNode);
							}
						}
						// No child
						else
						{
							Tree_Node_Deallocate(RemoveNode);
							parent->rightNode = NULL;
						}
					}
				}
				if (parent != NULL)
				{
					parent = parent->rightNode;
				}
			}	
		}
	}
	
	return BST;
}
// -------------------------------------------------------
void FindMin(struct BST *BST)
{
	struct Tree_Node *Tree_Node;

	if (BST != NULL)
	{
		Tree_Node = RecursiveMinSearch(BST->root->leftNode);
	}
	else
	{
		exit(0);
	}
	printf("\n\n\t\tMinimum value of this tree : %d", Tree_Node->value);
}
// -------------------------------------------------------
void FindMax(struct BST *BST)
{
	struct Tree_Node *Tree_Node;

	if (BST->root != NULL)
	{
		Tree_Node = RecursiveMaxSearch(BST->root->rightNode);
	}
	else
	{
		exit(0);
	}
	printf("\n\n\t\tMaximum value of this tree : %d", Tree_Node->value);
}
// -------------------------------------------------------
void MinHeight(int *numberNodesptr)
{
	if (*numberNodesptr != 0)
	{
		// n = 2 ^ h;
	}
	else
	{
		exit(0);
	}
}
// --------------------------------------------------------
void MaxHeight(int *numberNodesptr)
{
	if (*numberNodesptr != 0)
	{
		printf("\n\n\t\t\tMax Height of Tree : %d", *numberNodesptr); 
	}
	else
	{
		exit(0);
	}
}
// -------------------------------------------------------
void PreorderDisplay(struct BST *BST)
{
	// Root->Left->Right
	printf("\n\n\t\t    Preorder Traversal Display\n");

	if (BST->root != NULL)
	{
		RecursivePreorderDisplay(BST->root);
	}
	else
	{
		exit(0);
	}
}
// -------------------------------------------------------
void RecursivePreorderDisplay(struct Tree_Node *Tree_Node)
{
	// Root->Left->Right
	if (Tree_Node != NULL)
	{
		printf("\n\t\t\tValue of node : %d", Tree_Node->value);
		if (Tree_Node->leftNode != NULL)
		{
			RecursivePreorderDisplay(Tree_Node->leftNode);
		}

		if (Tree_Node->rightNode != NULL)
		{
			RecursivePreorderDisplay(Tree_Node->rightNode);
		}
	}
	else
	{
		exit(0);
	}
}

// -------------------------------------------------------
void InorderDisplay(struct BST *BST)
{
	// Left->Root->Right

	printf("\n\n\t\t    Inorder Traversal Display\n");

	if (BST->root != NULL)
	{
		RecursiveInorderDisplay(BST->root);	
	}
	else
	{
		exit(0);
	}
}
// -----------------------------------------------------
void RecursiveInorderDisplay(struct Tree_Node *Tree_Node)
{
	if (Tree_Node != NULL)
	{
		if (Tree_Node->leftNode != NULL)
		{
			RecursiveInorderDisplay(Tree_Node->leftNode);
		}

		printf("\n\t\t\tValue of node : %d", Tree_Node->value);
		
		if (Tree_Node->rightNode != NULL)
		{
			RecursiveInorderDisplay(Tree_Node->rightNode);
		}
	}
	else
	{
		exit(0);
	}
	/*
		1. First call left-node 
		2. After finished calling, return to point where its 
		   calling from which is root 
		   Display root value
        3. Call right node

        After finished calling itself, return to 
		previous stack where its calling from
		
    */
}
// -----------------------------------------------------
void PostorderDisplay(struct BST *BST)
{
	// Left->Right->Root

	printf("\n\n\t\t    Postorder Traversal Display\n");
	if (BST->root != NULL)
	{
		RecursivePostorderDisplay(BST->root);
	}
	else
	{
		exit(0);
	}
}
// -------------------------------------------------------
void RecursivePostorderDisplay(struct Tree_Node *Tree_Node)
{
	if (Tree_Node != NULL)
	{
		if (Tree_Node->leftNode != NULL)
		{
			RecursivePostorderDisplay(Tree_Node->leftNode);
		}

		if (Tree_Node->rightNode != NULL)
		{
			RecursivePostorderDisplay(Tree_Node->rightNode);
		}

		printf("\n\t\t\tValue of node : %d", Tree_Node->value);
	}
	else
	{
		exit(0);
	}
}
// ------------------------------------------------------
void SearchDisplay(struct Tree_Node *Tree_Node, int *resultSearched)
{
	if (Tree_Node != NULL)
	{
		if (Tree_Node->value == *resultSearched)
		{
			printf("\n\n\t\t\tResult of searched : %d\n", Tree_Node->value);
		}
		else
		{
			printf("\n\n\t\tSearch Not Found\n");
		}
	}
	else
	{
		exit(0);
	}
}
// ------------------------------------------------------
struct Tree_Node* Searching(struct BST *BST, int *numberptr)
{
    if (BST != NULL)
    {
		return RecursiveSearch(BST->root, numberptr);
    }
    else
    {
        exit(0);
    }
}
// -----------------------------------------------------
struct Tree_Node* RecursiveSearch(struct Tree_Node *Tree_Node
								  , int *numberptr, ...)
{
	struct Tree_Node* result;

	result = Tree_Node;

	if (Tree_Node != NULL)
	{
		if (Tree_Node->value == *numberptr)
		{
			return result;
		}
		else
		{
			if (Tree_Node->leftNode != NULL 
				|| Tree_Node->rightNode != NULL)
			{
				if (*numberptr < Tree_Node->value)
				{
					if (Tree_Node->leftNode != NULL)
					{
						return RecursiveSearch(Tree_Node->leftNode, numberptr);
					}
				}
				else
				{
					if (Tree_Node->rightNode != NULL)
					{
						return RecursiveSearch(Tree_Node->rightNode, numberptr);
					}
				}
			}
		}
	}
	return result;
}
// -----------------------------------------------------
struct Tree_Node* RecursiveMinSearch(struct Tree_Node *Tree_Node)
{
	if (Tree_Node != NULL)
	{
		if (Tree_Node->leftNode != NULL)
		{
			Tree_Node =  RecursiveMinSearch(Tree_Node->leftNode);
		}
	}
	return Tree_Node;
}
// ------------------------------------------------------
struct Tree_Node* RecursiveMaxSearch(struct Tree_Node *Tree_Node)
{
	if (Tree_Node != NULL)
	{
		if (Tree_Node->rightNode != NULL)
		{
			Tree_Node = RecursiveMaxSearch(Tree_Node->rightNode);
		}
	}
	else
	{
		exit(0);
	}
	return Tree_Node;
}
// ------------------------------------------------------
void BST_UserInput(int *numberptr)
{
    int value;

    printf("\n\n\t\t\tEnter a value : ");
    scanf("%d", &value);
 
    *numberptr = value;
}
// ------------------------------------------------------
int* QuerySearchValue(int *numberptr)
{
	int value;

	printf("\n\n\t\t\tEnter a value to search : ");
	scanf("%d", &value);

	*numberptr = value;
	return numberptr;
}
// -----------------------------------------------------
struct Tree_Node* Tree_Node_Allocate(struct Tree_Node *Tree_Node)
{
    Tree_Node = malloc(sizeof(struct Tree_Node));
    assert(Tree_Node != 0);

    Tree_Node->leftNode = NULL;
    Tree_Node->rightNode = NULL;
 
    return Tree_Node; 
}
// ------------------------------------------------------
void Tree_Node_Deallocate(struct Tree_Node *Tree_Node)
{
    if (Tree_Node != NULL)
    {
        free(Tree_Node);
        Tree_Node->leftNode = NULL;
        Tree_Node->rightNode = NULL;
    }
    else
    {
        exit(0);
    }
}
// -------------------------------------------------------
struct Tree_Node* Tree_Node_Initialize(struct Tree_Node *Tree_Node,
                                     int *numberptr)
{
    if (Tree_Node != NULL)
    {
        Tree_Node->value = *numberptr;
		Tree_Node->leftNode = NULL;
		Tree_Node->rightNode = NULL;
    }
    else
    {
        exit(0);
    }
 
    return Tree_Node;
}
// -------------------------------------------------------
int* numberTreeNodes(int *numberNodesptr)
{
	printf("\n\n\t\t\tEnter Number of Nodes : ");
	scanf("%d", &numberNodesptr);

	return numberNodesptr;
}
// -------------------------------------------------------
int* removeNode(int *removeptr)
{
	printf("\n\n\t\t\tEnter a value to remove : ");
	scanf("%d", removeptr);
	/*
		If pointer or array, no need address operator
	*/

	return removeptr;
}
// --------------------------------------------------------
__________________
Linux is the best OS in the world.
 
« Previous Thread | Next Thread »

Recent GIDBlogNew Corolla Altis, 10th Generation - Part I by Nihal

Thread Tools Search this Thread
Search this Thread:

Advanced Search
Rate This Thread
Rate This Thread:

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts
vB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Forum Jump

Similar Threads
Thread Thread Starter Forum Replies Last Post
Need help with a simple "dragon" game. ddaigle CPP / C++ Forum 13 04-Dec-2007 06:06
"Linker Error" problem with C++ The Great Dane CPP / C++ Forum 2 10-Nov-2007 16:55
Computer Game Design HELP NEEDED! dcallito CPP / C++ Forum 3 01-Jun-2007 12:29
Student programming questions Shawn Miscellaneous Programming Forum 1 02-Apr-2007 21:31
Tips for game troubleshooting pcxgamer Computer Software Forum - Games 0 02-Jan-2004 05:27

Network Sites: GIDNetwork · GIDWebHosts · GIDSearch · Learning Journal by J de Silva, The

All times are GMT -6. The time now is 21:11.

Contact Us - GIDForums™ - Archive - Top

vBulletin, Copyright © 2000 - 2008, Jelsoft Enterprises Ltd.