First, define the time complexity:

When analyzing the algorithm, the total execution times t (n) of the statement is a function of the problem scale n, and then analyze the change of T (n) with N and determine the order of magnitude of T (n). The time complexity of the algorithm, that is, the time measurement of the algorithm,

Record as T(n) = 0(f(n)).

It means that with the increase of problem scale n, the growth rate of algorithm execution time is the same as that of F (n), which is called the asymptotic time complexity of the algorithm, which is called time complexity for short, where f (n) is a function of problem scale n;

Say something reasonable.

The formula to measure the complexity of an algorithm must be simpler and faster under the same environmental conditions; Then what we pursue is to optimize those with high time complexity into those with low time complexity;

Calculation time complexity:

Calculate the time complexity of the following formula: f(n) = n^2f(n) = n^2 +2f(n) = 2n^2 +2f(n) = 3n^3 +2

Calculation principle:

1. Constants in algorithm functions can be ignored For example, 1. The following + 2

2. The constant factor of the highest power in the algorithm function can be ignored, such as 2 in front of No. 3: n^2 and 3 in front of No. 4

3. The smaller the highest power in the algorithm function, the higher the algorithm efficiency, and the ^ 2 after the letter n ^ 3. In this way, ^ 2 is more efficient than ^ 3;

Time complexity representation:

Definition of large notation:

When analyzing the algorithm, the total execution times t (n) of the statement is a function of the problem scale n, and then analyze the change of T (n) with N and determine the magnitude of T (n). The time complexity of the algorithm is the time measurement of the algorithm, which is recorded as: t (n) = O (f (n)); It means that as the problem scale n increases, the growth rate of the algorithm execution time is the same as that of F (n), which is called the asymptotic time complexity of the algorithm, or time complexity for short, where f (n) is a function of the problem scale n, such as the function of 1 2 3 4 fn listed above;

Important definitions:

Execution times = execution time

Generally, with the increase of input scale n, the algorithm with the slowest growth of T (n) is the optimal algorithm;

So how to deduce the big O notation?

(in fact, it's similar to the above principle)

1. Replace all addition constants in the running time with constant 1;

2. In the modified run times, only high-order items are retained

3. If the highest order term exists and the constant factor is not 1, remove the constant multiplied by this term;

Direct example:

f(n) = 3..........................................O(1)f(n) = n +2...........................O(n)f(n) = 2n^2 +2........................O(n^2)f(n) = 3n^3 +2........................O(n^3)

Better looking with code:

//You can copy to your idea and run the following public class CountOn { /**example: * f(n) = 3..........................................O(1) * f(n) = n + 2...........................O(n) * f(n) = 2n^2 +2........................O(n^2) * f(n) = 3n^3 +2 * * @param args */ public static void main(String[] args) { long result = function1(100); long result2 = function2(100); long result3 = function3(100); long result4 = function4(100); System.out.println("1 To 100 (Gaussian algorithm) time complexity O(1): " + result); System.out.println("1 Time complexity of sum (sequential addition algorithm) to 100 O(n): " + result2); System.out.println("100 1100, 2... Sum of 100, time complexity O(n^2): " + result3); System.out.println("100*100*100 The times are added successively from the beginning, with time complexity O(n^3): " + result4); } //Time complexity f(n) = 3........................................ O(1) private static long function1(long num) { return (1 + num) * num / 2; } //Time complexity f (n) = n.............................. O(n) private static long function2(long num) { long n = 100; for (long i = 0; i < n; i++) { num += i; } return num; } //Time complexity f (n) = n^2.................... O(n^2) private static long function3(long num) { long sum = 0; for (long i = 1; i <= num; i++) { for (int j = 1; j <= num; j++) { sum += i; } } return sum; } //Cubic order private static long function4(long num) { long sum = 0; for (long i = 1; i <= num; i++) { for (long j = 1; j <= num; j++) { for (int f = 1; f <= num; f++) { sum ++; } } } return sum; } }

The print result of the run is:

1 To 100 (Gaussian algorithm) time complexity O(1): 5050 1 Time complexity of sum (sequential addition algorithm) to 100 O(n): 5050 100 1100, 2... Sum of 100, time complexity O(n^2): 505000 100*100*100 The times are added successively from the beginning, with time complexity O(n^3): 1000000

Do an exercise to see if you get your ideas:

//Time complexity calculation exercise: //Find a number from the array, return true if found, and return false if not found. What is the time complexity of this code; public boolean findNum(int num) { //9 numbers, maybe n numbers int[] arr = {1, 56, 45, 23, 88, 99, 456, 0, 2}; //for loop of arr array length for (int i = 0; i < arr.length; i++) { if (num == i) { return true; } } return false; }

This time complexity is calculated in three cases:

1. Fortunately, the first element I just found is num ---------------- o (1)

2. Bad luck, just the last one is ----------------------- O(n)

3. Average situation--------------------------------------- O(n)

It's easy to understand. Finding elements one by one is actually similar to the process of adding 1 to n mentioned at the beginning;

Summary:

Understanding time complexity is an introduction to understanding algorithms and one of the criteria for analyzing the relative advantages and disadvantages of an algorithm;