void testSearch() { printf("Test 3. search: "); BinarySearchTree *tree = initTestTree(); Node *node = searchNode(tree, 3); if ((node == NULL) || (node->key != 3)) { printf("NOK - chybne hledani korene s hodnotou 3\n"); }else{ node = searchNode(tree, 2); if ((node == NULL) || (node->key != 2)) { printf("NOK - chybne hledani listu s hodnotou 2\n"); }else{ node = searchNode(tree, 7); if (node != NULL) { printf("NOK - hledany prvek 7 se ve strome nevyskytuje\n"); }else{ printf("OK\n"); } } } makeGraph(tree, "search.dot"); printf("Vykresleny strom najdete v souboru search.dot\n"); freeTree(tree); }
int addTran(char *name1,char *name2, int amount) { hashNode *node = searchNode(name2); hashNode *nodeInit = searchNode(name1); if(node==NULL || nodeInit==NULL) return 0; if(nodeInit->amount<amount) return 0; nodeInit->amount -=amount; node->amount+=amount; if(node->list==NULL){ //this account hasn't received any amounts from other accounts node->list = malloc(sizeof(listNode)); node->list->name = malloc(strlen(name1)*sizeof(char)); node->list->amount = amount; strcpy(node->list->name,name1); node->list->next=NULL; } else{ //this account has already received amounts from other accounts if(!strcmp(node->list->name,name1)){ node->list->amount+=amount; //already received amounts from this account return 1; } while(node->list->next!=NULL){ if(!strcmp(node->list->name,name1)){ node->list->amount+=amount; //already received amounts from this account return 1; } node->list=node->list->next; } node->list->next = malloc(sizeof(listNode)); node->list->next->name = malloc(strlen(name1)*sizeof(char)); node->list->next->amount = amount; strcpy(node->list->next->name,name1); node->list->next->next=NULL; } return 1; }
const T * segmentTree<T>::searchNode(const ssize_t nodeIdx, const ssize_t lftIdx, const ssize_t rhtIdx, \ const ssize_t lftQuery, const ssize_t rhtQuery) { if(lftIdx > rhtQuery || rhtIdx < lftQuery) { return NULL; } if( lftQuery <= lftIdx && rhtQuery >= rhtIdx) { return (&tree[nodeIdx]); } ssize_t midIdx = (lftIdx + rhtIdx) >> 1; ssize_t curNode = nodeIdx; ssize_t lftNode = getLftNode(curNode); ssize_t rhtNode = getRhtNode(curNode); const T *lftans = searchNode(lftNode, lftIdx, midIdx, lftQuery, rhtQuery); const T *rhtans = searchNode(rhtNode, midIdx + 1, rhtIdx, lftQuery, rhtQuery); if(!lftans) { return rhtans; } if(!rhtans) { return lftans; } return (*lftans < *rhtans ? lftans : rhtans); }
void fun(AdjGraph *adjGraph,char a[M],char p,char q) { int i,j,dist[M]; int minIndex,minle,temp; // int minLen[M]={0}; int qDex=findIndex(a,adjGraph->vexnum,q); ArcNode *head=adjGraph->arcGraph; ArcList *arcList=NULL; for(i=0;i<adjGraph->vexnum;i++) { dist[i]=MAXL; } dist[findIndex(a,adjGraph->vexnum,p)]=-1; arcList=searchNode(head,p); updateDist(dist,adjGraph->vexnum,arcList,qDex,p,0); for(j=1;j<adjGraph->vexnum;j++) { minIndex=findMinDist(dist,adjGraph->vexnum); // minLen[minIndex]=dist[minIndex]; temp=dist[minIndex]; if(minIndex==qDex) { minle=dist[minIndex]; break; } dist[minIndex]=-1; arcList=searchNode(head,a[minIndex]); updateDist(dist,adjGraph->vexnum,arcList,qDex,a[minIndex],temp); } printf("%d\n",minle); }
void network::addLink(string parent, string child) { node* p = searchNode(parent); node* c = searchNode(child); (*c).addParent(p); (*p).addChild(c); }
node searchNode(node p, book *f){ if(p==NULL) return p; else if(p->b->acc == f->acc) return p; else if(p->b->acc < f->acc) searchNode(p->right, f); else searchNode(p->left, f); }
struct node* searchNode(struct node *root, int value){ if (root == NULL) return NULL; else { if (root->value == value) return root; else { if (value < root->value) return searchNode(root->left,value); else return searchNode(root->right,value); } } }
int main(void) { printf("following is the test of binary tree:\n"); while(1){ struct btree *ptr_root=malloc(sizeof(struct btree)); init_btree(ptr_root); printf("\nplease input binary tree in pre-order:\n"); ptr_root=createBTree(); printf("\n\nprint btree in pre-order:\n"); preOrder(ptr_root); printf("\n\nprint btree in mid-order:\n"); midOrder(ptr_root); printf("\n\nprint btree in post-order:\n"); postOrder(ptr_root); printf("\n\nthis btree's nodes' amount: \n%d",countAllNodes(ptr_root)); printf("\n\nthis btree's height: \n%d",getHeight(ptr_root)); printf("\n\nthis btree's leaf's amount:\n%d",countLeaf(ptr_root)); printf("\n\nprint btree's leaf:\n"); displayLeaf(ptr_root); printf("\n\nfind 'a' and insert 'x' in left,then display all node in pre-oreder:\n"); struct btree *foundRoot=searchNode(ptr_root,'a'); insertLeftNode(foundRoot,'x'); preOrder(ptr_root); printf("\n\nfind 'a' and insert 'y' in left,then display all node in pre-oreder:\n"); foundRoot=searchNode(ptr_root,'a'); insertRightNode(foundRoot,'y'); preOrder(ptr_root); printf("\n\ndelete leftTree and display left node in pre-order:\n"); deleteLeftTree(ptr_root); preOrder(ptr_root); printf ("\n\ndelete rightTree and display left node in pre-order:\n"); deleteRightTree(ptr_root); preOrder(ptr_root); printf("\n\nclear btree!\n"); clearBTree(ptr_root); //clear input buffer char ch; while((ch=getchar())!='\n'&&ch!=EOF); } return 0; }
Node * searchNode(Node * a, T val) { if (a == NIL) return NIL; if (a->data == val) return a; if (a->data < val) return searchNode(a->right, val); else return searchNode(a->left, val); }
vector<int> searchNode(TreeNode* root, int k1, int k2) { // write your code here if (root == nullptr) return list; int mid = root->val; if (mid >= k1 && mid <= k2) list.push_back(mid); if (mid < k2) searchNode(root->right, k1, k2); if (mid > k1) searchNode(root->left, k1, k2); return list; }
/* Function to search an element in a Binary search tree */ void searchNode(int i, node **n) { if(*n == NULL) printf("\nValue does not exist in tree!"); else if((*n)->data == i) printf("\nValue found!"); else if(i > (*n)->data) searchNode(i, &((*n)->rightChildNode)); else searchNode(i, &((*n)->leftChildNode)); }
void searchNode(node * tree, double * x, double * y, int n) { if (tree == NULL) return; if(tree->index==n) { *x = tree->xcoord; *y = tree->ycoord; return; } searchNode(TLEFT, x,y,n); searchNode(TRIGHT, x,y,n); }
/* @Function name : QuickSort @Parameters : List to be sorted by Quicksort, first node of the list, last node of the list to be sorted @Returns : Sorted list @Descriptions : This function sorts the list according to quicksort methods @Error Cases : */ list* quickSort(list* orgList, int low, int high) { list_node* high_node = searchNode(orgList, high); list_node* low_node = searchNode(orgList, low); if (low < high ) { list_node *p = partition(low_node, high_node); int pivot = whereisNode(orgList, p); quickSort(orgList, low, pivot); quickSort(orgList, pivot+1, high); } return orgList; }
int searchNode(NodeT* root, int value) { if(root==NULL) return 0; else if(root->data==value) return 1; else { if(root->data < value) return searchNode(root->right, value); else return searchNode(root->left, value); } }
/* Description: Add a new edge to graph. * Input: Start node,End node and weight of edge * Output: NA. */ int Kruskal::addEdge(char startNodeName[], char endNodeName[], double label) { struct GraphEdge* newEdge = new GraphEdge(); newEdge->startNode = searchNode(startNodeName); newEdge->endNode = searchNode(endNodeName); if(!(newEdge->startNode && newEdge->endNode)) return -1; newEdge->label = label; newEdge->nextEdge = NULL; lastGraphEdge->nextEdge = newEdge; lastGraphEdge = newEdge; return 0; }
vector<int> searchRange(TreeNode* root, int k1, int k2) { // write your code here searchNode(root, k1, k2); sort(list.begin(), list.end()); return list; }
StringTreeNode* StringBinaryTree::FindByString(string str) { StringTreeNode searchNode(str); StringTreeNode* pRes = (StringTreeNode*) Find(&searchNode); return pRes; }
void deleteNode(const T &key) { std::pair<BSTNode<T>*, bool> pos_msg = searchNode(key); if (!pos_msg.second) return; if (pos_msg.first->left_child == nullptr)//delete node with only right_child deleteNodeAuxiliary(pos_msg.first, pos_msg.first->right_child); else if (pos_msg.first->right_child == nullptr) deleteNodeAuxiliary(pos_msg.first, pos_msg.first->left_child); else { auto p = minimumPtr(pos_msg.first->right_child);//use "successor": actually use "minimumPtr" if (p->parent != pos_msg.first) { deleteNodeAuxiliary(p, p->right_child); p->right_child = pos_msg.first->right_child; p->right_child->parent = p; } deleteNodeAuxiliary(pos_msg.first, p); p->left_child = pos_msg.first->left_child; p->left_child->parent = p; } delete pos_msg.first; pos_msg.first = nullptr; }
/** \brief Check if the word has already be set * * \param Trie : the dictionnary * \param Trie : words set in the grid * \param Cell[][] : grid of cell * \param int[][] : position of each letter * \return int : score of the word * */ int scoreWord(Trie *t, Trie *tGrid, Cell grid[N][N], int coord[17][2]) { int scoreWord = 0; int *pScoreWord = &scoreWord; char *word = getWordFromCoord(grid, coord); int lengthWord = strlen(word); // if the word has already been set if (searchNode(tGrid, word)) { printf("Word already found\n"); } else { // If the word exist in dictionnary if (searchWordTrie(t, word)) { scoreTotal(grid, coord, pScoreWord, lengthWord); } } // insert in the trie the word set insertNode(tGrid, word); free(word); return *pScoreWord; }
/* The main() program begins */ int main() { int ch, num, num1; do { printf("\nSelect a choice from the menu below."); printf("\n1. Insert a node."); printf("\n2. Search for a node."); printf("\nChoice: "); scanf("%d", &ch); switch(ch) { case 1: printf("\nEnter an element: "); scanf("%d", &num); insertNode(num, &rootNode); break; case 2: printf("\nEnter the element to be searched for: "); scanf("%d", &num); searchNode(num, &rootNode); break; default: exit(0); } printf("\nIf you want to return to the menu, press 1."); printf("\nChoice: "); scanf("%d", &num); } while(num == 1); return 0; }
void moveToNextNode(int currentNodeID ,int nextNodeID) //Decides on which node to move to { vertexNode* v = searchNode(currentNodeID); //Found the vertex node //Create a temp head edgeNode edgeNode* temp_head = v->head; orientation direction ; while(temp_head!=NULL) { if(temp_head-> id == nextNodeID){ direction = temp_head->turn; //lastTurn = direction; //lastPositionSeen = lastTurn; distanceToNextNode = temp_head->distance; break; } temp_head = temp_head->next; } moveCar(direction, distanceToNextNode); lastTurn = direction; printf("Node explored : %d \n", currentNodeID); // Rotate based on current orientation // Set the timers // Actuate Motors // Keep updating currentDistanceTravelled }
void Painting::unloadMemory(int n){ node *ptr = searchNode(n); if(ptr == NULL) cout<<"No Node with ID: "<<n<<endl; if(ptr == head){ //head = ptr->next; head = NULL; cout<<"ID: "<<n<<" is removed from Memory"<<endl; return; } node *cur = head; node *prev = head; while(cur){ if(cur == ptr){ prev->next = cur->next; return; } prev = cur; cur= cur->next; } }
void practice67(list_t list) { node_t* newNode1 = (node_t*)malloc(sizeof(node_t)); node_t* newNode2 = (node_t*)malloc(sizeof(node_t)); node_t* currentPtr; printf("\n주어진 노드(40) 다음에 새 노드(45) 추가하는 함수 구현\n맨앞(NULL뒤)에 새 노드(5) 추가하는 함수 구현\n\n"); newNode1->value = 45; newNode2->value = 5; printf("전체 리스트\n"); printAllNodes(&list); currentPtr = searchNode(&list, 40); insertNode(&list, currentPtr, newNode1); printf("40뒤에 45추가\n"); printAllNodes(&list); insertNode(&list, NULL, newNode2); printf("맨 앞에 5 추가\n"); printAllNodes(&list); fflush(stdin); getchar(); return; }
//search child nodes recursivly, then self void *searchDeep(spConfigNode*node,char *name,void*ref,char type,char found) { int i; void *ret=NULL; ENTRY; if(ref==NULL) found=1; for(i=0;i<node->numChildren;++i) { ret=searchDeep(node->children[i],name,ref,type,found); if(ret) { if(ret==(void*)-1) { DEBUG(-125,"Looks like we found something\n"); ++found; } else return(ret); } } //ok, so it wasn't there, but maybe ref was, lets look in root node return(searchNode(node,name,ref,type,found)); }
/* * The deleteNode is incomplete. It only deletes nodes * that are leaves. Otherwise, it doesn't change the tree. */ void deleteNode(Node ** ptr2link) { Node ** nodeptrptr; Node * nodeptr; Node * temp; Node * temp2; int event = 0; char c; /* Get the alphabet to delete */ while(1) { printf("Enter alphabet ('a' - 'z'): "); c = getchar(); while(getchar() != '\n'); /* get rid of extra characters from stdin */ if (c < 'a' || c > 'z') printf("\n Try again \n"); else break; } /* Search for the node */ nodeptrptr = searchNode(c, ptr2link); if (nodeptrptr == NULL) return; /* Couldn't find it */ /* Delete the node */ nodeptr = *nodeptrptr; if (nodeptr->left == NULL && nodeptr->right == NULL) { /* A leaf */ *nodeptrptr = NULL; /* Delete the node from the tree by NULLing the link from the parent node */ destroyNode(nodeptr); /* Deallocate space back to memory */ }else if (nodeptr->left == NULL && nodeptr->right != NULL) { *nodeptrptr = nodeptr->right; destroyNode(nodeptr); }else if (nodeptr->left != NULL && nodeptr->right == NULL) { *nodeptrptr = nodeptr->left; destroyNode(nodeptr); }else if (nodeptr->left != NULL && nodeptr->right != NULL) { temp = nodeptr->right; temp2 = nodeptr; while(temp->left != NULL){ temp2 = temp; temp = temp->left; event = 1; }if(temp->right != NULL){ if(event == 1){ temp2->left = temp->right; }else{ temp2->right = temp->right; } }else{ if(event == 1){ temp2->left = NULL; }else{ temp2->right = NULL; } }temp->right = nodeptr->right; temp->left = nodeptr->left; *nodeptrptr = temp; destroyNode(nodeptr); } }
int main(void) { int ch, num, num1; do { printf("\nSelect a choice from the menu below."); printf("\n1. Insert a node."); printf("\n2. Search for a node."); printf("\n3. Delete a node."); printf("\n4. Display the Binary Search Tree."); printf("\nChoice: "); scanf("%d", &ch); switch(ch) { case 1: printf("\nEnter an element: "); scanf("%d", &num); //printf("YESYES"); insertNode(num, &rootNode); break; case 2: printf("\nEnter the element to be searched for: "); scanf("%d", &num); searchNode(num, rootNode); break; case 3: printf("\nEnter the element to be deleted: "); scanf("%d", &num); deleteNode(num, rootNode); break; case 4: printf("\nSelect an order for the elements to be display in."); printf("\n1. Pre-order."); printf("\n2. Post-order."); printf("\n3. In-order."); printf("\nChoice: "); scanf("%d", &num1); switch(num1) { case 1: printf("\nPre-order Display: "); displayPreOrder(rootNode); break; case 2: printf("\nPost-order Display: "); displayPostOrder(rootNode); break; case 3: printf("\nIn-order Display: "); displayInOrder(rootNode); break; default: exit(0); } break; default: exit(0); } printf("\nIf you want to return to the menu, press 1."); printf("\nChoice: "); scanf("%d", &num); } while(num == 1); return 0; }
bool insert(const T& val) { Node** node = searchNode(val); if (*node != NULL) return false; *node = new Node(val); ++m_size; return true; }
void practice5(list_t list) { node_t* currentPtr; printf("\n주어진 key를 갖는 노드 찾는 함수 구현 70 & 100\n\n"); printf("전체 리스트: "); printAllNodes(&list); currentPtr = searchNode(&list, 70); currentPtr ? printf("%d is found\n", currentPtr->value) : printf("Key is Not Found!\n"); currentPtr = searchNode(&list, 100); currentPtr ? printf("%d is found!\n", currentPtr->value) : printf("Key is Not Found!\n"); fflush(stdin); getchar(); return; }
/** * getNameFunction */ char* getNameFunction(Parameters argv, int NumInstruction) { Instruction instruction; instruction = searchNode(argv.Instructions, NumInstruction); return instruction->NameFunction; }//getNameFunction
/** * getIndexPlugIn */ int getIndexPlugIn(Parameters argv, int NumInstruction) { Instruction instruction; instruction = searchNode(argv.Instructions, NumInstruction); return instruction->IndexPlugIn; }//getIndexPlugIn