int main() { char _[] = "deadbeef"; tree_t t = create_tree(_, strlen(_)); inorder_traversal(t, print_node); sep; printf("%c %c %c", retrieve(find_min(t)), retrieve(find_max(t)), retrieve(find('a', t))); sep; t = insert_tree('z', t); printf("%c %c %c", retrieve(find_min(t)), retrieve(find_max(t)), retrieve(find('a', t))); sep; inorder_traversal(t, print_node); sep; delete_tree('z', t); printf("%c %c %c", retrieve(find_min(t)), retrieve(find_max(t)), retrieve(find('a', t))); sep; inorder_traversal(t, print_node); dispose_tree(t); return 0; }
void find_min(int *a, int left, int right){ int mid = (left + right)/2; // Special case where min element is in last /*if(right - left == 1){ if(a[right] > a[left]) min = a[left]; else min = a[right]; return; }*/ if(left == right){ min = a[left]; return; } // If middle element itself is the min element if(a[mid] < a[mid-1]){ min = a[mid]; return; } if(a[left] < a[mid]) find_min(a, mid+1, right); else if(a[left] > a[mid]) find_min(a, left, mid-1); else{ min = a[mid]; return; } }
int find_min(int a[], int start, int end, int size) { debug_print(a, start, end); if (start == end) return (start); int mid = (start + end)/2; if (a[start] >= a[end]) { if (a[mid] < a[(mid + size - 1)%size]) return (mid); if (a[start] == a[mid] && a[mid] == a[end]) { /* this step makes the algo non-logarithmic */ int i = find_min(a, start, (mid == start) ? mid : mid-1, size); int j = find_min(a, (mid == end) ? mid : mid+1, end, size); if (a[i] < a[j]) return (i); else return (j); } if (a[start] >= a[mid]) return find_min(a, start, (mid == start) ? mid : mid-1, size); else return find_min(a, (mid == end) ? mid : mid+1, end, size); } else { /* no rotation */ return (start); } }
int find_min(TreeNode * root, TreeNode ** point) { int ret = 999999; if (root == NULL) { *point = NULL; return ret; } TreeNode * p_left; TreeNode * p_right; int left = find_min(root->left, &p_left); int right = find_min(root->right, &p_right); if (root->val < left && root->val < right) { *point = root; return root->val; } else if (left < right) { *point = p_left; return left; } else { *point = p_right; return right; } }
void drawPoly_zbuffer(void) { int x0, y0, x1, y1, i, j, k, p0, p1; double z0, z1, color, z; int minx, maxx, miny, maxy; for(i = 0;i<no_planes;i++) { find_vectors(i); color = intensity(); for(j=0;j<4;j++) { p0 =planes[i][j]; p1 =planes[i][(j+1)%4]; x0 = vertex[p0][0]; x1 = vertex[p1][0]; y0 = vertex[p0][1]; y1 = vertex[p1][1]; z0 = tmp_ver[p0][2]; z1 = tmp_ver[p1][2]; drawSlopeIndpLine(x0, y0, z0, x1, y1, z1); drawSlopeIndpLine(x0+1, y0+1, z0+1, x1-1, y1-1, z1-1); drawSlopeIndpLine(x0-1, y0-1, z0-1, x1+1, y1+1, z1+1); }// end of each line minx = find_min(vertex[planes[i][0]][0], vertex[planes[i][1]][0], vertex[planes[i][2]][0],vertex[planes[i][3]][0]); maxx = find_max(vertex[planes[i][0]][0], vertex[planes[i][1]][0], vertex[planes[i][2]][0],vertex[planes[i][3]][0]); miny = find_min(vertex[planes[i][0]][1], vertex[planes[i][1]][1], vertex[planes[i][2]][1],vertex[planes[i][3]][1]); maxy = find_max(vertex[planes[i][0]][1], vertex[planes[i][1]][1], vertex[planes[i][2]][1],vertex[planes[i][3]][1]); for(k=maxy;k>=miny;k--) { for(j=minx; j<=maxx;j++) { if(temp[k+H][j+W].flag) { z = temp[k+H][j+W].z; if (fabs(z - (double)cz) < fabs(zbuf[k+H][j+W] - (double)cz)) { zbuf[k+H][j+W] = z; frame_buffer[k+H][j+W] = color; color_buffer[k+H][j+W] = i; } } temp[k+H][j+W].flag = 0; } } }//end of each planes }
void dijkstra(graph* g, int source, item** ph) { int infinity = 100000000; int vertices = g->node_count; heap* h = make_heap(); for (int i = 0; i < vertices; i++) { item* itm = (item*)malloc(sizeof(item)); if (i == source) { itm->key = 0; } else { itm->key = infinity; } int* item_val = (int*)malloc(sizeof(int)); *item_val = i; itm->value = item_val; ph[i] = itm; insert_item(itm, h); } item* val = find_min(h); delete_min(h); while (val != NULL) { if (val->key == infinity) { break; } int u_index = *((int*)(val->value)); g_node* n = g->nodes[u_index]; for (int v_index = 0; v_index < n->edge_count; v_index++) { edge* e = n->edges[v_index]; int dist_between = e->distance; item* v = ph[e->target->id]; int alt = val->key + dist_between; if (alt < v->key) { int delta = v->key - alt; decrease_key(delta, v, h); } } val = find_min(h); delete_min(h); } }
/* delete_element_from_BST: Searches the BST for the target(student_id), if it * is found, then remove it from the BST. Returns the new BST back to the caller. * Params: the BST to delete an item from and target to search the BST for. * Returns: the BST once the delection is complete. */ BST delete_element_from_BST(BST self, long target) { if (self == NULL) { return NULL; } if (target < self->value) { self->left = delete_element_from_BST(self->left, target); } else if (target > self->value) { self->right = delete_element_from_BST(self->right, target); } else { if (self->left == NULL) { BST temp = self->right; free_node(&self); return temp; } else if (self->right == NULL) { BST temp = self->left; free_node(&self); return temp; } else { BST temp = find_min(self->right); self->value = temp->value; self->right = delete_element_from_BST(self->right, temp->value); } } return self; }
t_square find_square(t_map map) { int i; int j; t_square max; i = map.n - 2; if (map.m == 1) return (line_column(map, 1)); else if (map.n == 1) return (line_column(map, 2)); max.size = 0; while (i >= 0) { j = map.m - 2; while (j >= 0) { if (map.oriz[i][j] != 0) { map.oriz[i][j] = find_min(map, i, j) + 1; if (map.oriz[i][j] >= max.size) { max.size = map.oriz[i][j]; max.corner.x = i; max.corner.y = j; } } j--; } i--; } return (max); }
unsigned find_min(struct node *t) { if (t->left == NULL) return t->value; else return find_min(t->left); }
bst_ret remove(node * cur){ node * aux = NULL; if(cur == NULL) return bst_ErrParm; /* while the current node is not a leaf node */ while( cur->lchild != NULL || cur->rchild != NULL ) { /* The node has no left subtree */ if(cur->lchild == NULL){ aux = find_min(cur->rchild); swap(cur, aux); } /* The node has or doesn't have a right subtree */ else { aux = find_max(cur->lchild); swap(cur, aux); } cur = aux; } /* Fix the the pointers of cur's parent */ if(cur->parent->lchild == cur) cur->parent->lchild = NULL; else if(cur->parent->rchild == cur) cur->parent->rchild = NULL; free(cur->key); free(cur); return bst_Ok; }
static bs_tree_node_t* delete_node(bs_tree_t* tree, bs_tree_node_t* node, void* key) { int cmp = tree->compare(node->key, key); if(cmp < 0) { if(node->left) delete_node(tree, node->left, key); else return NULL; } else if(cmp > 0) { if(node->right) delete_node(tree, node->right, key); else return NULL; } else { if(node->left && node->right) { bs_tree_node_t* successor = find_min(node->right); swap_nodes(successor, node); replace_node_in_parent(tree, successor, successor->right); return successor; } else if(node->left) replace_node_in_parent(tree, node, node->left); else if(node->right) replace_node_in_parent(tree, node, node->right); else replace_node_in_parent(tree, node, NULL); return node; } }
void ugly_number() { unsigned int ugly[1500] = {0}; ugly[0] = 1; unsigned int pos2, pos3, pos5; pos2 = pos3 = pos5 = 0; int i; for(i=1; i < 1500; ++i) { while( ugly[pos2] * 2 <= ugly[i-1]) pos2++; while( ugly[pos3] * 3 <= ugly[i-1]) pos3++; while( ugly[pos5] * 5 <= ugly[i-1]) pos5++; int a = ugly[pos2] * 2; int b = ugly[pos3] * 3; int c = ugly[pos5] * 5; ugly[i] = find_min(a, b, c); } printf("The 1500'th ugly number is %d.\n", ugly[i-1]); }
struct bst* del(struct bst *T,int data) { if(T==NULL) return T; else { if(data<T->data) T->left=del(T->left,data); if(data>T->data) T->right=del(T->right,data); if(data==T->data) { if(T->left && T->right) { struct bst *tmpcell; tmpcell=find_min(T->right); T->data=tmpcell->data; T->right=del(T->right,tmpcell->data); } else { struct bst *tmpcell; tmpcell=T; if(T->left==NULL) T=T->right; else if(T->right==NULL) T=T->left; free(tmpcell); } } return T; } }
int *auction_algorithm_sse(float **graph) { int j, terminal, arg_min, *path; float min, j_dist, *prices, *dist_price; path = init_path(); // init to INFINITIES prices = init_prices(); // init to zeroes dist_price = (float *) // to hold distance to neighbour _mm_malloc(GRAPHSIZE // + neighbour price * sizeof(float), 16); // and be used with sse path[0] = 0; // start off with the source node terminal = 0; // point to current end of path while (path[terminal] != TARGET) { dist_price_sse(graph[path[terminal]], // calculate all dist_price values prices, dist_price); find_min(dist_price, path, // find the minimum in there &arg_min, &min); // choose step if (prices[path[terminal]] < min) { // step 1 prices[path[terminal]] = min; // p := min if (terminal != 0) // contract P path[terminal--] = INFINITY; } else { // step 2 path[++terminal] = arg_min; // extend P } } return path; }
Node * BST::deleteBSTNodeHelper(Node *node,int data){ if(node == NULL){ return node; } else if(data<node->data){ node->left=deleteBSTNodeHelper(node->left,data); } else if (data>node->data){ node->right=deleteBSTNodeHelper(node->right,data); } else{ //Delete the node!!! if(node->left == NULL && node->right == NULL){ delete node; node=NULL; } else if(node->left == NULL){ Node *tmp=node; node=node->right; delete tmp; } else if(node->right == NULL){ Node *tmp=node; node=node->left; delete tmp; } else{ Node *tmp=find_min(node->right); node->data = tmp->data; node->right=deleteBSTNodeHelper(node->right,tmp->data); } } return node; }
int find_min(struct treeNode *t) { if (t->left == NULL) return t->value; else return find_min(t->left); }
void delete_elem(node** t, int val) { if(!(*t)) return; if((*t)->data < val) delete_elem(&(*t)->right, val); else if((*t)->data > val) delete_elem(&(*t)->left, val); else { if((*t)->dup_count) // there were no duplicates --(*t)->dup_count; else { node* del; if(!(*t)->left) { del = (*t); (*t) = (*t)->right; free(del); } else if(!(*t)->right) { del = (*t); (*t) = (*t)->left; free(del); } else { del = find_min((*t)->right); (*t)->data = del->data; delete_elem(&(*t)->right, del->data); } } } }
static int backtrack_other(struct saucy *s) { int cf = s->start[s->lev]; int cb = cf + s->right.clen[cf]; int spec = s->specmin[s->lev]; int min; /* Avoid using pairs until we get back to leftmost. */ pick_all_the_pairs(s); clear_undiffnons(s); s->npairs = s->ndiffnons = -1; if (s->right.lab[cb] == spec) { min = find_min(s, cf); if (min == cb) { min = orbit_prune(s); } else { min -= cf; } } else { min = orbit_prune(s); if (min != -1 && s->right.lab[min + cf] == spec) { swap_labels(&s->right, min + cf, cb); min = orbit_prune(s); } } return min; }
/* implement the 'g' graphing command */ void do_graph1(csv_t *D, int col) { /* fix column number to match array indexing */ int array_col=col-1; row_buckets_t graph_buckets; int graph_values[GRAPHROWS] = {0}; /* determine the min and max of the column */ graph_buckets.min = find_min(D, array_col); graph_buckets.max = find_max(D, array_col); /* use the min and max to compute the size of the buckets */ graph_buckets.bucket_step_size = bucket_size(graph_buckets.max, graph_buckets.min, GRAPHROWS); /* fill an array of buckets, where the value of each index is the lower end of the bucket range */ row_bucket_values(&graph_buckets); /* fill an array determining how many values are in each bucket */ fill_buckets(&graph_buckets, D, array_col, graph_values); /* print the graph of bucket quantities per bucket value */ print_bucket_graph(&graph_buckets, D->labs[col-1], graph_values); }
//finds the minimum value in the node's subtree recursively bst_n *find_min(bst_n *node) { if(node->left == NULL) { return node; } else { return find_min(node->left); } }
// ------------------------------------------------------------------------------ // Funcao exclude // ------------------------------------------------------------------------------ nodo * exclude (nodo * raiz, element * x) { nodo * temp, * filho; // se a arvore estiver vazia if (raiz == NULL){ printf("Erro nodo nao encontrado"); return NULL; } else if (x->valor < raiz->chave->valor){ // esquerda raiz->esq = exclude(raiz->esq, x); raiz = balanceamento(raiz); } else if ( x->valor > raiz->chave->valor){ // direita raiz->dir = exclude(raiz->dir, x); raiz = balanceamento(raiz); } else if (raiz->esq && raiz->dir) { // se tiver 2 filhos temp = find_min(raiz->dir); raiz->chave->valor = temp->chave->valor; raiz->dir = exclude(raiz->dir, raiz->chave); } else { // filho unico temp = raiz; if (raiz->esq == NULL) // so tem filho a direita filho = raiz->dir; if (raiz->dir == NULL){ // so tem filho a esquerda filho = raiz->esq; } free(temp); return filho; } return raiz; }
int main(int argc, char *argv[]) { tree_node_t *root = NULL; node_value data[TEST_DATA_NUM] = {6, 2, 8, 1, 4, 9, 10, 11}; root = insert(7, root); int i = 0; for (; i < TEST_DATA_NUM; i++) { insert(data[i], root); } logprintf("---left root right---"); ldr_print(root); tree_node_t *tmp = find_min(root); logprintf("%sfind_min()%s = %d", YELLOW, NORMAL, tmp->element); tmp = find_max(root); logprintf("%sfind_max()%s = %d", YELLOW, NORMAL, tmp->element); node_value search = 8; tmp = find(search, root); if (NULL != tmp) { logprintf("%ssearch: %d is in tree%s", MAGENTA, search, NORMAL); } return 0; }
AVLTree find_min(AVLTree root) { if(root->lson == NULL) { return root; } return find_min(root->lson); }
void selection_sort (int arr[], int start, int end) { for (int i = 0; i < end; i++) { int ptr = find_min (arr, i, end+1); exchange(arr, i, ptr); } }
static void switch_and_sort(t_lst *l, t_elem *second, t_options *options) { more_effective_moving(l, second, options); sa(l); if (options->v == 1) show_piles(l, "sa"); more_effective_moving(l, find_min(&l->a), options); }
int main() { //int array[] = {12, 15, 22, 56, 94, 3, 7, 11}; int array[] = {30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 10, 20, 21, 22, 23, 24, 25, 26, 27, 29}; //int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; printf("min of array is %d with O(logn)\n", find_min(array)); printf("min of array is %d with O(n)\n", find_min_n(array)); return 0; }
PRIVATE int move_rset(Encoded *Enc, struct_en *str){ /* count better neighbours*/ int cnt = 0; /* deepest descent*/ struct_en min; min.structure = allocopy(str->structure); min.energy = str->energy; Enc->current_en = str->energy; if (Enc->verbose_lvl>0) { fprintf(stderr, " start of MR:\n "); print_str(stderr, str->structure); fprintf(stderr, " %d\n\n", str->energy); } // construct and permute possible moves construct_moves(Enc, str->structure); /* find first lower one*/ int i; for (i=0; i<Enc->num_moves; i++) { Enc->bp_left = Enc->moves_from[i]; Enc->bp_right = Enc->moves_to[i]; cnt = update_deepest(Enc, str, &min); if (cnt) break; } /* if degeneracy occurs, solve it!*/ if (deal_deg && !cnt && (Enc->end_unpr - Enc->begin_unpr)>0) { Enc->processed[Enc->end_pr] = str->structure; Enc->end_pr++; str->structure = Enc->unprocessed[Enc->begin_unpr]; Enc->unprocessed[Enc->begin_unpr]=NULL; Enc->begin_unpr++; cnt += move_rset(Enc, str); } else { /* write output to str*/ copy_arr(str->structure, min.structure); str->energy = min.energy; } /* release minimal*/ free(min.structure); /* resolve degeneracy in local minima*/ if (deal_deg && (Enc->end_pr - Enc->begin_pr)>0) { Enc->processed[Enc->end_pr]=str->structure; Enc->end_pr++; int min = find_min(Enc->processed, Enc->begin_pr, Enc->end_pr); short *tmp = Enc->processed[min]; Enc->processed[min] = Enc->processed[Enc->begin_pr]; Enc->processed[Enc->begin_pr] = tmp; str->structure = Enc->processed[Enc->begin_pr]; Enc->begin_pr++; free_degen(Enc); } return cnt; }
/** * Find distance of minimum time intercept with line * * @param h Altitude of intercept to be set if solution found (m) * * @return Time of arrival (or -1 if no solution found) */ fixed solve(fixed &h) { fixed h_this = find_min(m_h_min); fixed t = f(h_this); if (t < fixed_big) { h = h_this; return t; } return fixed(-1); }
/** * Find distance of minimum time intercept with line * * @param distance Distance of intercept to be set if solution found (m) * * @return Time of arrival (or -1 if no solution found) */ fixed solve(fixed &distance) { fixed distance_this = find_min(m_d_min); fixed t = f(distance_this); if (t < fixed_big) { distance = distance_this; return t; } return fixed(-1); }
fixed TaskSolveTravelled::search(const fixed ce) { #ifdef SOLVE_ZERO return find_zero(ce); #else return find_min(ce); #endif }