What are some algorithms which we use daily that has O(1), O(n log n) and O(log n) complexities? More on stackoverflow.com

Let's start with some basics. You have some input X={x0,x1,...,xn} and some algorithm F which, when run on X, produces some output F(X). You want to know how long it takes to run. The obvious answer is to grab a stopwatch and time it. This will tell you how long it takes to run for a specific input. You can run it with many different inputs and write down the results, and for most algorithms, you'll likely notice that the running time mainly depends on is the number of items in X. So you can imagine there being a function t=T(F,n) that returns the running time for the algorithm and input size. These calculations are likely to be finicky, because they have to account for all the particulars of the implementation. So for example, suppose you analyze a bubblesort algorithm, calculate the running time of each line, figure out how many times that line is executed, and come up with T(bubblesort,n)=0.00037n(0.00173n+0.000074)+0.000731. You look at several other sorting algorithms and come up with even more complex functions. And of course the constants are only valid for the particular computer you ran or analyzed the timings on. These functions are interesting, but not particularly handy for a programmer or mathematician who wants to be able to talk in a convenient way about the running times of algorithms in general. To make things easier, we make two simplifying assumptions: first, that the main thing we're interested in is how these T-functions behave when n is large, and second, that we're interested in how they behave relative to each other (ie, not on any particular computer). This brings us to big-O notation. A big-O term like O(n^(2)) represents a set of T-functions. For the first assumption above, we choose specifically those for which the term n^(2) dominates in the limit as n goes to infinity. Recall from calculus that in the limit of a polynomial, the highest power term dominates. And for the second assumption, we eliminate all multiplicative constants. This brings us to the formal definition: O(g(n))={f(n) : ∃c∃k∀n n>k⇒0≤f(n)≤cg(n)} This says that when we say f(n)∈O(g(n)), we mean that we can choose arbitrary constants c and k such that for all n>k, f(n) is always less than or equal to c * g(n). Less formally, for large n, f(n) differs from g(n) only by a multiplicative constant. What does this actually mean when we make claims about algorithms? Suppose we know some algorithm - let's call it slowsort - is O(n^(2)). This means that if you went to the trouble of measuring and defining a T-function for slowsort on your computer, that this T-function would be in the set of functions which differ only by a multiplicative constant from t=f(n^(2)) for large n. Importantly, this says very little about small values of n. If you're going to spend all your time sorting 10-item lists, then the big-O classification isn't useful to you. But it does tell you something about the behavior as you scale up the input size. Suppose we also know that another algorithm - let's say fastersort - is O(n log n). It's important to understand that this does not tell us that fastersort is actually faster or slower for any specific value of n we might have in mind. Perhaps fastersort takes an hour to organize its working memory before it even gets started. But in the limit, as n goes to infinity, there will eventually be some value of n above which the O(n log n) algorithm always dominates the O(n^2) algorithm. Hopefully this is reasonably clear. There are more complex situations, like when the running time doesn't just depend on a single value for the input size and we see things like O(m*n). But even then, the key points are that we're talking about what happens for arbitrarily large values, and that we're making a statement about what category the algorithm's T-function falls in to. (Note that my use of set theory here is at odds with many standard CS textbooks. Big-O notation was first used by Paul Bachmann in 1894, making it older than modern set theory. The original big-O notation would write f(n)=O(n^(2)) instead of f(n)∈O(n^(2)). In the original notation, the equals sign does not mean algebraic equality, but rather establishes a relationship of classification between the left and right sides. This leads to endless confusion in a modern context since people can't help reading = as algebraic equality.) More on reddit.com

In my mind, the coefficient would be kept as it does have a significant effect even as n grows, however I recall hearing that you are not meant to include it? Keep in mind that while people like to give intuitive explanations of big O, it has a specific formal definition. f(n) is O(g(n)) if lim f(n)/g(n) < inf as n -> inf. If f(n) = 3g(n) and g(n) != 0 then you get f(n)/g(n) = 3g(n)/g(n) = 3 which is less than infinity, and therefore f(n) is O(g(n)) despite the constant. If you want to try to develop some intuition for why things are defined this way, think about it in terms of scaling. Let's say you have 100,000 users and need to do some sort of operation on all of them. Doing 3 times as many operations isn't ideal, but it's manageable, and the tradeoff doesn't really change if you go to 1,000,000 users—you're still just doing 3 times as many operations. However, if you're instead of doing n times as many operations, the characteristics change a lot when you 10x your user base—you go from having a working solution to an infeasible one, rather than a working solution to a slightly more expensive but still working solution. Are you meant to add the time complexities of the functions? Do you simply use the greatest order time complexity? (Finite) addition and taking the max are the exact same operation when it comes to big O. If you're working on the math side of big O, this isn't difficult to prove and is a good exercise. My reasoning is that I'm pretty sure (n(n-1))/2 is the number of edges in a complete graph, however I can't help but feel that it is incorrect. Your reasoning is totally correct, assuming you represent your edges as pairs of vertices and actually put together a data structure. Of course, if your implementation is more abstract (e.g. it contains a set of vertices and then just returns true if asked whether any given pair is connected) then it might not take that long to construct. More on reddit.com

Big Oh isn’t super complicated. Effectively you are trying to characterize your algorithm and determine its worst possible run time complexity. This is typically going to be determined by how many loops you use. A big part of optimizing code is trying to reduce the number of loops in your codebase. Something with O(1) is called “constant” time and takes one operation to return — like looking something up in a hashmap for example. Something with O(n) is called “linear” time — ie it takes n steps to compute. This might be iterating over a list of numbers to get a sum or an average, for example Something with O(n2) is called “quadratic” time — ie it takes n2 steps to process an input. This might be iterating over one object in your array and then iterating over a child list in each parent object, for example. When interviewers ask about this, it’s mostly to make sure you are loosely familiar with the concept of algorithmic complexity. More on reddit.com