## How to calculate O(Log(N))?

o(n log n) explained

big o calculator

o(n log n) code example

log(n graph)

o(log n vs o(n))

big o notation

theta log n

I want to know exactly how to calculate O(Log(N)) for this exemple : we have a sorted array of 10 elements [1 3 4 8 10 15 18 20 25 30] When we do a normal search we have a complexity of O(10) that means that we have to check every case of the array so O(10) = 10. but if we do a dichotomic search because we have a sorted array we have a complexity of (O(Log(10)) what's is the result of this notation O(Log(10))= ??? ? i have a missunderstand shall we use Log base 10 or 2 or what exactly ? thanks for the help

You have misunderstood the concepts of algorithmic order of growth. Please read a book on algorithms and get your concepts strong. In any case I'll try explaining at a high level,

If you have an array of 10 elements like you said, and you do a "normal search" (It's called Linear Search) you are iterating through each element in the array, which means that if there are 'n' elements 'n' elements have to be checked. So it's O(n) not O(10). If it were O(10) [ btw, O(10) = O(1) ] that would mean that the it would always take 10 iterations or less, no matter how many elements there were in the array, which is not the case. If your array had 100 elements, it would take 100 iterations so we say the order is O(n) where n is the input size (here the size of the array).

The above method is for a non sorted array, for a sorted array we can use a faster method to search, much like how you would look up a word in a dictionary, this technique is called Binary Search. What happens here is, you look up the middle element of the array and see where the number you are searching for lies, either on the first half or the next half. Then, you select the half you want and apply the same method of dividing into half and checking. Since this is being done recursively, it uses logarithmic growth (in case of binary search, it is log to base 2). Please read up on Binary Search and logarithmic order of growth for a better understanding.

**How to calculate O(Log(N))?,** One place where you might have heard about O(log n) time complexity the first time is Binary search Which makes our equation into. Time complexity: O(log n) Auxiliary space: O(log n) if the stack size is considered during recursion otherwise O(1) Using inbuilt log function. We only need to use logarithm property to find the value of log(n) on arbitrary base r. i.e., where k can be any anything, which for standard log functions are either e or 10

I think you are confused about why a binary search is log(n) and why it's base 2. Think of it this way, at every step in your binary search , you are reducing your input size by 2. How many times do you need to do this ? You need to do this log n to the base 2 times in order to reduce your sample size to 1.

For example if you have 4 elements, first step reduces the search to 2, the second step reduces the search to 1 and you stop. Thus you had to do it log (4) to the base 2 = 2 times. In other words if log n base 2 = x, 2 raised to power x is n.

So if you are doing a binary search your base will be 2. More clearly, in your case Log(10) base 2 will be something around 3.3 i.e you will be making at most 4 comparisons.

**What does the time complexity O(log n) actually mean?,** The term log(N) is often seen during complexity analysis. This stands for logarithm of N, and is Duration: 12:39
Posted: Jan 27, 2018 You want to know if there is an easy way to identify if an algorithm is O (log N). Well: just run and time it. Run it for inputs 1.000, 10.000, 100.000 and a million. If you see like a running time of 3,4,5,6 seconds (or some multiple) you can safely say it's O (log N).

**Simplifying log(N) in Algorithms,** Algorithm Analysis Practice Online Lesson For Algorithm Analysis: https://www.udemy.com Duration: 6:46
Posted: Sep 16, 2018 One place where you might have heard about O(log n) time complexity the first time is Binary search algorithm. So there must be some type of behavior that algorithm is showing to be given a complexity of log n. Let us see how it works. Since binary search has a best case efficiency of O(1) and worst case (average case) efficiency of O(log n

i have a missunderstand shall we use Log base 10 or 2 or what exactly

It does not matter. The complexity does not change. Log base 2 is the same as:

Log_2(N) = Log(N) / Log(2)

Both are elements of `O(Log(N))`

.

**Prove log(n^3) is O(log n),** If you're new to computer science, you've probably seen a notation that looks something like O(n) or O(log n). That's time complexity analysis or Anti-logarithm calculator. In order to calculate log-1 (y) on the calculator, enter the base b (10 is the default value, enter e for e constant), enter the logarithm value y and press the = or calculate button:

Well, O-notation doesn't give the exact value of the complexity function. It gives growth rate. If you say that

T(*n*) = O(lg *n*)

means that the time algorithm require to search through the array of *n* elements if you increase *n* will grow not faster than lg *n*.

The question you asked should be putted in different manner. The question you could ask is how many steps of iteration (or recursion) the algorithm would need to search through the array of *n* elements.

And the answer to this question is that algorithm would need not more than

(**int**)(lg *n*)

steps.

So if you have array of 10 elements, than the algorithm will find requested value (or find that it doesn't exist in the array) in not more than lg 10 = 3 steps of iteration.

**A Gentle Explanation of Logarithmic Time Complexity,** I know with O(n), you usually have a single loop; O(n^2) is a double loop; O(n^3) is a triple loop, etc. How about O (log n)?. You're really going about it the wrong a) Time complexity of the function should be O(Log y) b) Extra Space is O(1) Examples: Input: x = 3, y = 5 Output: 243 Input: x = 2, y = 5 Output: 32. We strongly recommend that you click here and practice it, before moving on to the solution.

**Determining if an Algorithm is O (log n),** For example, although the worst-case running time of binary search is Θ ( log 2 n ) \Theta(\log_2 n) Θ(log2n)\Theta, left parenthesis, log, start base, 2, end We use a variable to represent the size of the input, which everyone in the industry calls n. So the "loop over the list" function is O(n) where n represents the size of a_list. Checking whether an element is equal to 1 is an O(1) operation. A way to prove to ourselves that this is true is to think about it as a function.

**Big-O notation (article) | Algorithms,** When we calculate big O notation, we only care about the dominant conquer algorithms, O(log(n)) is generally a good complexity you can The natural logarithm of a number is its log to the base of the constant e, where e is approximately equal to 2.718281828459. The equation is written as log e (x) . If a logarithm does not specify a base , like this example: log(1000) , it's known as a common logarithm that uses the base 10 .

**What is Big O Notation Explained: Space and Time Complexity,** The process of abstracting away details and determining the rate of resource usage in terms of Algorithms that run in O(log n) does not use the whole input. O (log n) - Logarithmic Time As the size of input n increases, the algorithm's running time grows by log (n). This rate of growth is relatively slow, so O (log n) algorithms are usually very fast. As you can see in the table below, when n is 1 billion, log (n) is only 30.

##### Comments

- thanks for the comment , my problem is i have an algorithmic problem that i want to resolve but i have the constraint of execution of 2 seconds in a CPU of 1 GHZ, so i wonder how to calculate exactly the complexity to know if my algorithm is correct or not when i have i want to calculate O(Log(N)) i'm blocked
- @satyres: Read on "
*order of growth*", either from a book or online. Only that can help you understand better. Your ideas are very wrong. - can you give me a link please !
- I'd actually advise against wikipedia for this; their technical sites often times are convoluted and overly broad for a beginnner, which to me seems to be the case regarding the site on Landau and O-notation. Maybe this introductory material by MIT is more suitable for beginners.
- Try watching this <a href="youtube.com/… playlist</a> which is about asymptotic analysis
- although I don't disagree with the other answers, this one comes closest to solving the question. And @satyres as for a course on Algorithms, the MIT lectures would be good. Or try the fantastic Khan Academy, I think they should have topics on this too
- thanks for the comment ,in a normal array in order to search for an item i have to look after every case so O(10)= 10 right ! but what's the result for dichotomic serach O(Log(10)) thanks ?