Menu
  • HOME
  • TAGS

Would this function be O(n^2log_2(n))?

big-o,computer-science

O(65536 n2 + 128 n log2n) is the same as O(n2 + n log2n) since you can ignore multiplicative constants. O(n2 + n log2n) is equal to O(n2) since n2 grows faster than n log2n. Also, by the way, the base of logarithms doesn't matter in Big-O analysis. All logarithms...

For sets S and T, why does Python's S -= T take O(len(T)) and not O(len(S))?

python,big-o,python-internals

Technically, there is not really a requirement in the operation that S is larger than T. It’s easily possible that T is actually much larger than S: >>> S = {1, 2, 3} >>> T = {3, 4, 5, 6, 7, 8, 9} >>> S - T {1, 2} So,...

How are the following functions O(N^3)?

algorithm,big-o

Do you know, f(n) = O(g(n)) implies f(n) <= constant* g(n), right? In other words, it means, when you plot the graph of f(n) and g(n) then after some value of, g(n) will always be more than f(n). Here g(n) is N^3 and remaining comes in f(n). Now, N^3 is...

Decreasing the run time for my recursive subset sum algorthim

java,algorithm,recursion,big-o,subset-sum

Some minor optimizations if I understand this correctly: public static void recDfs(int[] arr, int k, int sum) { if (sum < 0) return; if (sum == 0) { counter++; return; } if (k == 0) { return; } recDfs(arr, k - 1, sum - arr[k - 1]); recDfs(arr, k -...

Big-O Computational Resources

algorithm,sorting,big-o,computer-science,asymptotic-complexity

The reason that comparisons are such an important factor, is because you could always store things by pointer, worst comes to worst, and make swaps the same for any types of keys. These simple system tricks will not work for comparisons. Comparing strings by lexicographic order is inherently more expensive...

TIme complexity of various nested for loops

loops,for-loop,big-o,time-complexity,asymptotic-complexity

If c=1 in loop 1 and loop 2 then it will run infinite times right but it is given as logarithimic time why? Yes you are right, if c = 1 then we will get infinite loops for both case 1 and case 2, so the condition "c is...

algorithms: how do divide-and-conquer and time complexity O(nlogn) relate?

performance,algorithm,big-o,divide-and-conquer

I think all the answers to your question might come from the Master Theorem It kind of tell you what would be your complexity for almost any divide and conquer solution you have, and yes, it has to do everything with recursion trees, by playing with the parameters you will...

Where do exponent denominators (fractional exponents) in big-O time complexity come from?

algorithm,big-o,time-complexity

They are coming from strict analysis of the complexity function. One common example is for Matrix Multiplication, while the Naive solution is O(n^3) multiply operations, there are some faster solutions. One of the first improvements offered to use 7 (instead of 8) multiplications operations to multiply two 2X2 matrices. If...

time complexity analysis for finding the maximum element

algorithm,big-o,time-complexity,lower-bound

Yes, that's correct. One way to see this is via an adversarial argument. Suppose that you have an algorithm that allegedly finds the maximum value in the array, but doesn't inspect every array element at least once. Suppose I run your algorithm on some array A1 that consists of nothing...

Sum of all subparts of an array of integers

arrays,algorithm,sum,big-o,subset

You can easily solve this problem with a simple recursive. def F(arr): if len(arr) == 1: return (arr[0], 1) else: r = F(arr[:-1]) return (11 * r[0] + (r[1] + 1) * arr[-1], 2 * r[1] + 1) So, how does it work? It is simple. Let say we want...

Exponential growth doubling processor speed

algorithm,big-o,complexity-theory,exponential

What the entry says is something like this. Suppose the algorithm is exponential with base c, so that for some input of size x, the running time is t ~= cx. Now given a processor twice as fast, with an input just a (I'm calling your constant that) larger, the...

Determining the Big O complexity for “for” loops.

big-o,time-complexity

For the first one, A: You need to se how many iterations the inner loop makes in total. So how many iterations does the inner loop have? It will have first 1, then 2, then 3 all the way until N^2. So we get: For the next one, B: Again,...

Big O notation for g(n) > h(n)

algorithm,big-o

Yes, it is correct, because g(n) + h(n) < g(n) + g(n) <= 2*g(n), so you found a constant C=2 such that f(n) <= C*g(n) (for large enough values of n), and by definition of big O, it means f(n) is in O(g(n))

How to find the Big O when there are two separate for loops

c,for-loop,big-o

It just gets added. See for e.g. : for(i=0;i<n;i++) //statements for(i=0;i<m;i++) //statements So the total complexity is O(m+n). lets say m=3n then its O(4n) which is O(n) only . let m = n^2 then its O(n^2+n) which is O(n^2)...

Determining number of calls (activations) to mergesort

algorithm,big-o,mergesort

As 32 is 25, the recursion tree will be a full binary tree. We then do 1 + 2 + 4 + 8 + 16 + 32 = 63 calls to mergesort. It is unclear to me why the answer would be 31, when they state the base case is...

What part of my code is making my performance suffer? (Codility's MaxCounter)

java,algorithm,data-structures,big-o,time-complexity

Instead of calling Arrays.fill(answer, minimumValue); whenever you encounter a "max counter" operation, which takes O(N), you should keep track of the last max value that was assigned due to "max counter" operation, and update the entire array just one time, after all the operations are processed. This would take O(N+M)....

Can you do addition/multiplication with Big O notations?

algorithm,big-o,time-complexity

At least for practical purposes, the Landau O(...) can be viewed as a function (hence the appeal of its notation). This function has properties for standard operations, for example: O(f(x)) + O(g(x)) = O(f(x) + g(x)) O(f(x)) * O(g(x)) = O(f(x) * g(x)) O(k*f(x)) = O(f(x)) for well defined functions...

I'm timing a function that has a runtime of O(n^3) but my timing results do not show this, why is this happening?

matlab,big-o,time-complexity

Since the O() behavior is asymptotic, you sometimes cannot see the behavior for small values of N. For example, if I set numberOfSizes = 9 and discard the first 3 points for the polynomial fit, the slope is much closer to 3: randomMPolyfit = polyfit(log10(sizesArray(4:end)), log10(randomMAveragesArray(4:end)), 1); randomMSlope = randomMPolyfit(1)...

Storing pairwise sums in linear space

arrays,algorithm,sorting,big-o,asymptotic-complexity

The problem, as I understand it, is that we want to find the sums a1 + b1 a1 + b2 ... a1 + bn a2 + b1 a2 + b2 ... a2 + bn ... ... ... ... an + b1 an + b2 ... an + bn and print...

How can I tell how many times these nested statements will execute?

algorithm,sorting,big-o,time-complexity,complexity-theory

The outer for-loop would run for n times. But, it also holds an inner for-loop which is dependent on the vale of j. I think that the first for-loop test will execute n times, and the nested for-loop will execute 1 + 2 + ... + n = n(n+1)/2 times....

How can we prove that the running time bound of an algorithm is tight?

algorithm,big-o,computer-science,big-theta

Wouldn't it suffice to give a special input and show that the running time is at least f(n)? Yes, assuming you are talking about the worst case complexity. If you are talking about worst case complexity - and you have proved it is running in O(f(n)), if you find...

Which Sieve of Eratosthenes implementation is more efficient?

java,algorithm,big-o

The second is more efficient. It is also the Sieve of Eratosthenes. The first algorithm is trial division, and is not the Sieve of Eratosthenes. The first algorithm has a time complexity of O(n sqrt(n)), or perhaps a bit less if you use only primes as trial divisors. The second...

Would this algorithm run in O(n)?

algorithm,big-o,time-complexity,complexity-theory,asymptotic-complexity

Sometimes you can simplify calculations by calculating the amount of time per item in the result rather than solving recurrence relations. That trick applies here. Start by changing the code to this obviously equivalent form: private static IntTreeNode createBST(int[] array, int left, int right) { int middle = array[(left +...

Ternary vs Chained If-else-if (Performance)

c#,performance,if-statement,big-o,ternary

Note that both solutions are very different. The first one only assigns true to one of those four variables while the other one will overwrite whatever value all four of them had before. That being said, using the ternary operator in the second code is really bad. You can just...

How to find out time complexity of mergesort implementation?

algorithm,big-o,time-complexity

The function in the code denoted as mergeSort() takes O(n) time, it is looping constant number of times over the elements within range (low,high). The function denoted as partition(), which is the actual sorting function, takes `O(nlogn) time. It can actually be denoted as: T(n) = 2T(n/2) + C*n //for...

time complexity of non-inplace binary search

big-o,time-complexity,complexity-theory,binary-search

As always, there can be a difference of the complexity of an algorithm and its implementation. If you implement binary search in a recursive function, that takes a copy of a part of the input array, this array has to be generated in O(n), so you are right, that this...

Performance Improvement Basics in Python

python,algorithm,performance,big-o

The slowest thing you do is copying a part of the list: current = num[lower:upper]. This brings the complexity of this step up from O(n) to O(n•k). What you really should do is just take the elements, which define the unfairness of this sublist directly by their indexes: min_unfairness =...

Time complexity of Boggle solver

python,algorithm,big-o,time-complexity

The solve function turns one element after an other into #, in worst case until the whole grid contains only #. But since you start at a specific point in the grid and only allow the next # to be a direct neighbor, you do not get all the (N²)!...

Why do we ignore co-efficients in Big O notation?

algorithm,big-o,time-complexity,complexity-theory

The purpose of the Big-O notation is to find what is the dominant factor in the asymptotic behavior of a function as the value tends towards the infinity. As we walk through the function domain, some factors become more important than others. Imagine f(n) = n^3+n^2. As n goes to...

Why, algorithm and data structure, both are not considered together when doing Big O complexity analysis?

algorithm,data-structures,big-o,time-complexity

You're mixing green apples with red apples here. Take your example, for instance - a Red-Black Tree's insert and remove methods keep it balanced. So when you search for a value, worst case O(log(n)) is because there's no sorting of any kind done. The tree is already "sorted" according to...

Analysis of a Bubble-sort algorithm

algorithm,sorting,big-o,bubble-sort

This case is much harder than the algorithm with two for loops, as the exact number of iterations of the outer loop does not depend just on N, but also on the particular arrangement of the data. If the array is initially sorted, there will be no swaps at all...

what are the relationship between O(nlogn)+O(n), O(nlogn) and O(nlogn + n)?

algorithm,big-o

Yes, you can say that's an O(nlogn). When you are trying to estimate complexity of your algorithm you start with all parts (choose the worst operation which is in each part and ignore the fast ones - hey it's just an estimate). First part is nlogn and the second part...

Choose the right algorithm

c++,algorithm,big-o

Can't really prove it (and it's late here), but the algorithm should take first element as P and Q, (P=0, Q=0), and iterate the rest of the array, and for each element E calculate L for just three pairs, (P, E), (Q, E) and (E, E). If one of them...

Time complexity of python code for finding the longest word that can be made of other words in the list

python,performance,big-o,time-complexity

Let n be the number of words in the list and m the length of the longest word. The for-loop iterates over the words until valid_word returns true. The worst case would be, that non of the words can be concatenated from other words in the list. So this gives...

Dropping non-constants in Algorithm Complexity

algorithm,graph,big-o,complexity-theory,bellman-ford

Yes, O(VE + V + E) simplifies to O(VE) given that V and E represent the number of vertices and edges in a graph. For a highly connected graph, E = O(V^2) and so in that case VE + V + E = O(V^3) = O(VE). For a sparse graph,...

What is the complexity of these two string based algorithms?

java,performance,algorithm,big-o,time-complexity

when using O() notation you ignore constants, which means that O(n) == (10^10*n). so while O(n^2)>O(n) is true asymptotically, its not necessarily true for smaller values of n. in your case imagine that maybe resizing the array behind the hashset could be more time consuming than iterating the input.

Big-O for 2 dimensional array and Linked list

c++,c,arrays,linked-list,big-o

2 dimensional array called a[10][10] exists, when I insert a[5][5]=1 is it O(1)? Nope, it is O(row index + column index), because you need to find one linked list by traversal, then the node in it by another traversal. A linked list exists with N nodes, then in order...

Best algorithm to find N unique random numbers in VERY large array

performance,algorithm,big-o,bigdata,asymptotic-complexity

If the odds of hitting a non-unique value are low, your best bet will be to select 3 random numbers from the array, then check each against the entire array to ensure it is unique - if not, choose another random sample to replace it and repeat the test. If...

Have I properly sorted these runtimes in order of growth?

math,big-o,time-complexity,asymptotic-complexity

I don't believe that the ordering you've given here is correct. Here are a few things to think about: Notice that 2log4 n = 2(log2 n / log2 4) = 2(log2 n) / 2. Can you simplify this expression? How fast does the function eπ4096 grow as a function of...

Most efficient way to calculate Fibonacci sequence in Javascript

javascript,algorithm,big-o,fibonacci

If you don't have an Array then you save on memory and .push calls function fib(n) { var a = 0, b = 1, c; if (n < 3) return 1; while (--n) c = a + b, a = b, b = c; return c; } ...

Big O notation for the complexity function of the fourth root of n

algorithm,math,big-o,time-complexity,complexity-theory

Using O(n^1/4) is perfectly fine for big O notation. Here are some examples of fractures in exponents from real life examples O(n) is also correct (because big O giving only upper bound), but it is not tight, so n^1/4 is in O(n), but not in Theta(n) n^1/4 is NOT...

Confused about the big O notation of the code

python,big-o

I believe it will be O(n^2) because your x value tends to increment, but your y value can continue to be reset to zero, therefore being no better than a nested loop.

Proof of O(loga n) = O(logb n), for any base a or b

algorithm,big-o,logarithm

The rule for changing base of a logarithm is: log_b(n) = log_a(n) / log_a(b). This immediately implies log_b(n) = O(log_a(n)) and by symmetry log_a(n) = O(log_b(n))....

Big O notation example confusion

big-o

The basis of the big-O notation is to determine how the size of the input (e.g., number of elements in an array) will effect the number of operations you need to perform. In these cases, C represents a constant, however large it may be, that satisfies the inequality when n...

Partitioning a set of values in Python

python,algorithm,dictionary,data-structures,big-o

We can do linear: values = [7, 3, 2, 7, 1, 9, 8] range_by_min, range_by_max = {}, {} for v in values: range_by_min[v] = range_by_max[v] = [v, v] for v in values: if v - 1 in range_by_max and v in range_by_min: p, q = range_by_max[v - 1], range_by_min[v] del...

Why is the cost of a hash lookup O(1) when evaluating the hash function might take more time than that?

hash,hashtable,big-o,time-complexity

When talking about hashing, we usually measure the performance of a hash table by talking about the expected number of probes that we need to make when searching for an element in the table. In most hashing setups, we can prove that the expected number of probes is O(1). Usually,...

Big-O complexity java

java,big-o

Well, at first: The Big O notation is not related to the programming language, it only depends on the implementation. So it is irrelevant if you do the loops in Java or any other language (besides some optimizations performed by the interpreter/compiler, which will, however, change the program flow) For...

Update minimum spanning tree if edge is removed

algorithm,graph,tree,runtime,big-o

Since everything is still connected and only one edge has been removed, then most (and maybe all) of the spanning tree remains the same. Attempt to construct the same minimum spanning tree, and if the edge that was removed was part of the spanning tree, grab the next smallest edge...

Big-O proof involving a sum of logs

math,big-o,logarithm

There are two useful mathematical facts that can help out here. First, note that ⌈x⌉ ≤ x + 1 for any x. Therefore, sum from i = 1 to n (⌈log (n/i)⌉) ≤ (sum from i = 1 to n log (n / i)) + n Therefore, if we can...

Big O complexity decision

java,algorithm,big-o

Let's refer to this.xMap*this.yMap*this.zMap as matrix-size. It looks O((matrix-size)^2) to me. Since direcciones is being appended to some constant number of times per run of the outer loop, calls to copiar are O(matrix-size) in time. Then each loop iteration adds at most the size of Dir3D items (also a constant)...

Why is only one of the given statements about complexity classes correct? [closed]

algorithm,big-o,time-complexity,complexity-theory

Wikipedia says :- Big O notation describes the limiting behavior of a function when the argument tends towards a particular value or infinity, usually in terms of simpler functions. A description of a function in terms of big O notation usually only provides an upper bound on the growth rate...

Finding sum of x^k from k= 0 to n in O(logn) time

c,algorithm,big-o

One way to look at the sum is as a number in base x consisting of all 1s. For e.g, 44 + 43 + 42 + 41 + 40 is 11111 in base 4. In any base, a string of 1s is going to be equal to 1 followed by...

Big-O run time for adding N items into ArrayList

java,arraylist,big-o

The dynamic array is well-studied in computer science in amortized time analysis. The short answer is that when starting from an empty dynamic array and adding N elements, the total time is O(N). You are correct that adding a single item has the worst-case time of O(N) when a resize...

Intro to Algorithms (chapter 1-1)

algorithm,big-o

For each time T, and each function f(n), you are required to find the maximal integer n such that f(n) <= T For example, f(n) = n^2, T=1Sec = 1000 ms: n^2 <= 1000 n <= sqrt(1000) n <= ~31.63 <- not an integer n <= 31 Given any function...

Which Algorithm is faster?

algorithm,big-o,code-complexity

As far as big-O is concerned, the two are equal: you can freely subtract constants and divide by constants, so both algorithms are linear in the number of their inputs - i.e. they are O(n). In general, big-O will not tell you exactly how fast an algorithm is. It boils...

Update minimum spanning tree if edge is added

algorithm,graph,tree,runtime,big-o

Don't know if your algorithm is correct, but it doesn't seem O(|V|) at least, because getting the "smallest edge not in T" of a vertex cannot be done in O(1). The most usual way to add an edge e=(u, v) into a MST T is: Run a BFS in T...

Is the execution time of this unique string function reduced from the naive O(n^2) approach?

c++,c,algorithm,big-o

No, it's still O(n^2). You just slightly improved the constant. You still have to make two loops- basically the naive count the loops way of measuring big O time should tell you this. Also, there is no such thing as O(n+1/2n). Big O notation is to give you an idea...

O notation proof for exponents and power

algorithm,big-o,time-complexity,complexity-theory,exponential

Well, your method is also concrete. You should proceed in the same direction. Currently, I also don't have a better option. 4^n = ((2^2)^n) = (2^2n) = (2^n) * (2^n) > 2^n for all values of n>0. As, (2^n) * (2^n) > O(2^n) . This is because (2^n) * (2^n)...

How to calculate the T(N) for this primes finder algorithm

algorithm,big-o,complexity-theory

The inner loop iterates over the array of all primes below sqrt(i). So you have to calculate the number of elements in that array. In the case of an array of primes, you have to use approximations for π(i), the number of primes below i. You can approximate them by...

Compute the “lower contour” of a set of segments in the plane in `O(n log n)`

c++,algorithm,big-o,computer-science

A sweep line algorithm is an efficient way to solve your problem. As explained previously by Brian, we can sort all the endpoints by the x-coordinate and process them in order. An important distinction to make here is that we are sorting the endpoints of the segment and not the...

Understanding Big-Ω (Big-Omega) notation

algorithm,big-o

Big O,Theta or Omega notation all refer to how a solution scales asymptotically as the size of the problem tends to infinity, however, they should really be prefaced with what you are measuring. Usually when one talks about big O(n) one usually means that the worst case complexity is O(n),...

Algorithm efficiency analyze

algorithm,big-o

What you teacher wants from you is to solve this system of equation: x*2048*log(2^11) = 11 x*4*2048*log(2^13) = y where: 2048 = 2^11 8192 = 2^13 = 4*2048 x is some cost of processing of an operation, it is the same in the both cases because the computer is the...

What is the Time Complexity of finding the max k integers?

python,algorithm,dictionary,big-o,time-complexity

for n in nums: if n > least_max: max_nums[least_max_key] = n least_max_key = min(max_nums, key=max_nums.get) # this is O(k) least_max = max_nums[least_max_key] You're doing an O(k) operation n times, so the complexity of your second function is O(n*k). Assuming you want the output in sorted order, this can be done...

Algorithm for matrix addition and multiplication

algorithm,matrix,time,big-o,matrix-multiplication

Your algorithm for matrix multiplication is wrong, and will yield a wrong answer, since A*B_{i,j} != A_{i,j} * B_{i,j} (with exception for some unique cases like zero matrix) I assume the goal of the question is not to implement an efficient matrix multiplication, since it's a hard and still studied...

Big O Notation with Absolute Value?

graph,big-o,notation

In set theory notation |A| is the cardinality of set A, in other words the number of elements contained in set A. For Reference: http://www.mathsisfun.com/sets/symbols.html...

Big O with removing an element each time

big-o,asymptotic-complexity

There's a methodology using Sigma notation that is precise enough: ...

Wouldn't this algorithm run in O(m log n)?

java,algorithm,runtime,big-o,time-complexity

Using that approach to building a heap, yes, but there is an O(n) algorithm for converting an array to a heap. See http://en.wikipedia.org/wiki/Binary_heap#Building_a_heap for details. That said, an O(m) time, O(n) memory solution exists for this problem, implemented by e.g. Guava's Ordering.leastOf. One implementation is create a buffer, an array...

Determining the big-O runtimes of loop with inner loop repeat time is const

algorithm,math,big-o,time-complexity,complexity-theory

No, you haven't made any mistake. You are correct in thinking so and is your solution perfect! The outer-loop will run n-times and the inner loop runs for 5(constant) times. Therefore, the loops complexity will be O(5*n) = O(n) and the other statements are of constant time-complexity. Since, 5*n times...

What is better BigO log(m*n) or (m+n)?

algorithm,big-o

Neither one is "best" outside the context of a specific application. Remember that O(f(x)) means that the time an algorithm takes to process an input of size x is proportional to f(x), with no indication of what that proportion is. If you have one algorithm that is O(n) (i.e. linear),...

BIG O In absence of enough information

performance,algorithm,big-o,complexity-theory,growth-rate

If you would talk about drawing the line, I'd simply like to deliver like :- The code's complexity :- O(N*o(X)) As soon as one get's to judge the complexity of the function X(N), one can simply substitute in the formula. Till then, it will be a shorthand but useful notation...

Why are my nested for loops taking so long to compute?

algorithm,matlab,time,big-o,nested-loops

As @horchler suggested you need to preallocate the target array this is because your program is not O(N^4) without preallocation each time you add new line to array it need to be resized so new bigger array is created (as matlab do not know how big array it will be...

Compare growth of function

algorithm,big-o

Your answer is correct. As for what you need to prove or not, that really depends on the context. If this is for an algorithms paper, you can assume that everyone reading your paper would know this. If this is for a class, the best answer would be to check...

Complexity O(n^3) vs O((logn)^4))

big-o

You can use L'Hopital rule to calculate the limit ...

Algorithm time complexity with binary search

time,big-o,time-complexity,binary-search-tree,binary-search

Update Yes, You are absolutely right. In the worst case function() will be invoked 31 times, and each invocation requires time O(n), hence the running time of your algorithm is simply given by 31 * O(n) = O(n). Solution for the original question where x = function(mid) Your question is...

is this the most efficient way?

java,arrays,big-o

How about not sorting the array first, but just traversing it, collecting the minimum and maximum value? public static double linear(double[] ar) { double max = Double.NEGATIVE_INFINITY; double min = Double.POSITIVE_INFINITY; for(double elem: ar){ if(min > elem) {min = elem;} if(max < elem) {max = elem;} } return Math.abs(max-min); }...

Calculating the Recurrence Relation T(n)=T(n / log n) + Θ(1)

algorithm,recursion,big-o,complexity-theory,recurrence

It looks like the lower bound is pretty good, so I tried to proof that the upper bound is O(log n / log log n). But let me first explain the other bounds (just for a better understanding). TL;DR T(n) is in Θ(log n / log log n). T(n) is...

How to get Omega(n)

algorithm,big-o,complexity-theory,big-theta

The Master theorem doesn't even apply, so not being able to use it isn't much of a restriction. An approach which works here is to guess upper and lower bounds, and then prove these guesses by induction if the guesses are good. a(0) = 0 a(1) = 1 a(2) =...

Counting the basic operations of a given program

c++,performance,runtime,big-o

When the article you are following says "for var <- 0 to var2", it is like "for (var = 0; var <= var2; var++), so yes, when i = 0, it enters the "for" twice (once when i = 0, and again when i = 1, then it goes out)....

What is the big-O complexity of this code

big-o,time-complexity

It is O(n). Big O is meant to describe the complexity of the application and in this case it is linear so it is O(n).

Big-O of Triple Nested Loop

java,big-o

for (int i = 1; i < n; i++) { // O(n) time complexity for (int j = 1; j < i; j++) { // O(n) time complexity for (int k = 1; k < j; k++) { // O(n) time complexity x++; } } } The first loop does...

Binary search - worst/avg case

search,big-o,time-complexity,complexity-theory,binary-search

For binary search, the array should be arranged in ascending or descending order. In each step, the algorithm compares the search key value with the key value of the middle element of the array. If the keys match, then a matching element has been found and its index, or position,...

Big-O of Dijkstra's Algorithm with D-Ary Heap

algorithm,heap,big-o,dijkstra

In a d-ary heap, up-heaps (e.g., insert, decrease-key if you track heap nodes as they move around) take time O(log_d n) and down-heaps (e.g., delete-min) take time O(d log_d n), where n is the number of nodes. The reason that down-heaps are more expensive is that we have to find...

Big-O insert for 2 dimensional array

c++,c,arrays,big-o

You are not inserting, right? You are assigning, direct to a specific address and you don't need to figure out the right position before hand. That means you don't need to do any loop, don't need to go through any computing before find the position and assign, and the memory...

first and last terms of a nested loop, sums of arithmetic series starting with non zero index

algorithm,math,big-o,computer-science,integer-arithmetic

Edit: Your previous question shows that you are interested in the number of terms in the inner summation. The loop for j<- first to last has last-first+1 terms (this is easiest to see if you write down some examples with small last-first). So for (1), there are (2n-i)-(1)+1=2n-i terms for...

Interpreting multivariate big-Oh notation

algorithm,big-o

how can I determine if O(f) is better asymptotically than O(g)? That depends on the relation between f and g, i.e. it depends on what actual arguments the caller uses. It's in other words impossible to answer the question without widening the scope of it. If you have implicit...

What is the big o notation of this algorithm?

big-o

Big O notation is derived from calculating the time complexity. You must take into account the amount of work in which your algorithm is doing. Please see below my answer in which I derive Big 0. This is using LateX which is a nice tool to write equations. Notes The...

What is the Big-O complexity of this code?

big-o,time-complexity

The formal definition of big-O notation is f(x) ∈ O(g(x)) as there exists c > 0 (e.g., c = 1) and x0 (e.g., x0 = 5) such that f(x) < cg(x) whenever x > x0. From your thinking, it seems you don't understand that if there is a constant that...

Running time Functions for nested for-loop

performance,algorithm,big-o,analysis,growth-rate

My best guesses: O( N * log(sqrt(N)) ) Doesn't have closed form expression because of: [indefinite integral of x^x] cannot be expressed in terms of a finite number of elementary functions... [1] O( N^3 ) ...

How can i find a running time of a recurrence relation?

recursion,big-o,complexity-theory

If you use the master theorem, you get the result you expected. If you want to proof this "by hand", you can see this easily by supposing n = 2m is a power of 2 (as you already said). This leads you to T(n) = 2⋅T(n/2) + O(n) = 2⋅(2⋅T(n/4)...

Big O Nested for Loop issue

java,big-o

Outer loop will run exactly n times, while inner loop is dependant on the value of i. But basically, it is doing 0, 1, ..., n-1 loops, which is total of (0 + n-1) * (n) / 2 = (n^2 - n) / 2 which is O(n^2)

How is it possible for Java HashMap to perform constant time lookup O(1) for “get” operations?

java,algorithm,hashmap,big-o

Here is my two cent, friend. Think of a HashMap the way you think of an array. In fact, it is an array. If I give you index 11, you don't have to iterate through the array to find the object at index 11. You simply go there directly. That's...