What does the key wizard quick sort a faster and more efficient algorithm than bubbling look like?

Bubbling sort is the least efficient. Juvenile! You can quickly sort it, and you will understand it in minutes.

The closed line of the wide song is bubbling and sorted.

Obviously, the fast sort has high efficiency, and the fast sort is based on the dichotomous method, the time complexity is o(nlogn), and the bubbling sort is o(n 2).

The bubbling time is n 2, and the fast discharge is n log n, so the fast discharge is faster.

Bubbling is a swap sorting. Let the n data be placed in the array elements a(1) to a(n) in turn, and the process of incrementally sorting the n data by bubbling method is as follows: first compare a(1) and a(2), exchange them if they are in reverse order, then compare a(2) and a(3), and exchange ...... if they are in reverse orderIn turn, the first round of comparison exchange is completed only when a(n-1) and a(n) are compared.

A second exchange ...... is then made with the same rulesUntil the data is ordered. In the worst-case scenario, compare 1 2 n(n-1) times and exchange 3 2 n(n-1) times.

Quick sort is a high-efficiency sorting algorithm proposed by a famous computer scientist on the basis of bubble sorting. Its basic idea is to select an element (usually the first element) x in the sequence to be sorted, and after exchanging positions many times according to a certain law, it moves to a certain position, and divides the original sequence by this position, so that the obtained two sub-sequences conform to the sorting law for x.

Element x is called the dividing element in this sequence. Then divide the two word sequences in this way until you get a sub-series that does not need to be further divided. This process is distinctly recursive.

Quick sort is more efficient than bubbling sort in most cases, and if you need an algorithm or **, you can hi yourself.

In the worst case, the entire sequence is already ordered or completely reversed.

At this point, the quicksort degenerates into a bubbling sort, which needs to be compared n2 times to complete.

In the worst case, the data elements are all ordered, and the number of decompositions of the root nodes of the data element array constitutes a binary degenerate tree (i.e., a single-branch binary tree), and the depth of a binary degenerate tree is n, so the time complexity of the quicksort algorithm in the worst case is o(n2).

The first two answers are almost complete, the whole sequence is in order, but usually the benchmark element to be compared at the beginning is randomly selected, so that the probability of the worst-case scenario is the lowest, which is one-nth of the nth power of two, which is small enough. If this is the worst. The character is indeed very good.

Web Links.

You can see it when you look at it.

The ideal time complexity of quicksort and merge sort is o(nlogn), but the time complexity of quicksort is not stable, and the complexity is o(n 2) in the worst case, so the ideal algorithm is still merge sorting, but if the landlord uses C++, there is a sort() function in the algorithm library.

Sort profiles quickly.

Merge and sort data.

sort function method.

It doesn't matter if the number of data is small, and quick sorting is generally the best way to use large data volumes. See.

The data is simple.

int p[100000];

int n;

int arrsize;

long long t1=0,t2=0;

n = 10000;

arrsize = 10+ rand()%9991;

while (n-->0)

Write your own caltime function.

The template parameters must be given, int type, and again the two template parameters must add a space in the middle.

The time complexity of quicksort is o(n), the time complexity of bubble sort is o(n) in the ideal state, and o(n*n) in the worst case. The general average is nlogn

Abstract points, you can think of it like this, if it is arranged from small to large:

Bubbling sorts move the small ones forward and the large ones backward, which may be slow, but ensures that each move will have a minimal move to the first position in the sequence.

Quick sort is to divide a sequence into two small sequences, and then divide them according to this method until there are only two or less to order, which is to ensure order, and it is a combination of small sequences from small to large to form an ordered sequence.

In a sense, quicksort is the processing from the whole to the parts to the individual; Bubbling sorting, on the other hand, is an individual comparison, so quicksort is more advanced than bubbling sorting, but it's so fast that it's unstable. However, since quicksort is a sequence that separates a sequence according to the small and large and then processes the sorting of smaller segments, it may run faster than bubbling sorting, so quicksort is an improvement on bubbling sorting.

Truth be told, there is no fastest.

This said. If you don't care about wasting space, it should be the bucket that sorts the fastest.

If the whole is basically ordered, the insertion sort is the fastest.

If you consider the overall situation, quick sort is more practical and common (Hill sorting, heap sorting, etc. also have their own advantages and disadvantages).

In general, the order of bubbling is just a fun name, and it is not very easy to use.

Direct insertion sorting: When the data is ordered, the execution efficiency is the best, and the time complexity is o(n). When the data is basically out of order, the execution efficiency is the worst, and the time complexity is o(n2). So the closer the data is to ordering, the better the performance of the direct insertion sorting algorithm.

Hill Sort: Time efficiency is o(n(log2n)2).

Direct selection sorting: Time efficiency is o(n 2) – there are fewer moves, but there are still more comparisons.

Heap sorting: The time efficiency is o(nlog2n).

Bubbling sorting: time efficiency is o(n 2) – because of the worst-case scenario (all data elements are in reverse order), of course, the best case is that all data elements are ordered, and the time complexity is o(n) if the time complexity is o(n).

Quick sort: Time efficiency: In general, the time complexity is o(nlog2n), and the worst case is that all data elements are ordered in forward or reverse order, and each time the standard element divides the current array into a subarray whose size is 1 smaller than the current array, the time complexity is o(n2).

Randomization Quick Sort...

Bucket sorting seems to be the fastest.