Database entry-level algorithm [2]

In the previous article "database entry-level algorithm 1", we introduced some data algorithms. Now we will continue to introduce some basic sorting algorithms.

Bubble Sorting

Usage conditions:The element of the set can be compared to the size.

Algorithm idea:Scan the records to be sorted continuously. The minimum record is found every time it is scanned to bring it closer to the top. Because a record is placed in the correct position at the end of each scan, you do not need to re-check the record for the next scan.

Example programming:Int B [10] = {77,1, 65,13, 81,93,} Sort it by bubble (here I am confused about the concept, thanks to zdd)

 
 

  
  
// Bubble sort
  
  
Void Bubble (int B [10])
  
  
{
  
  
Int temp;
  
  
Int I;
  
  
For (I = 9; I> 0; I --)
  
  
{
  
  
For (int j = 0; j 
  
  
{
  
  
If (B [j]> B [j + 1])
  
  
{
  
  
Temp = B [j];
  
  
B [j] = B [j + 1];
  
  
B [j + 1] = temp;
  
  
}
  
  
}
  
  
}
  
  
Cout <"the sort is :";
  
  
For (int I = 0; I <10; I ++)
  
  
{
  
  
Cout < 
  
  
}
  
  
Cout < 
  
  
}
 
 

Performance analysis:Time complexity O (n ^ 2)

Hill sorting

Usage conditions:The element of the set can be compared to the size.

Algorithm idea:First, the entire sequence of records to be sorted is divided into several sub-sequences for direct insertion and sorting. When the records in the whole sequence are "basic order", all records are directly inserted and sorted at a time. Subsequences are not simply "segmented by segments", but are separated by a "incremental" record to form a subsequence. Therefore, records with small keywords are not moved forward step by step, but are moved incrementally by step. This increment shows a decreasing trend, and the last increment is always 1, at this time, the sequence is basically ordered, as long as a few comparisons and moves to complete the sorting. Hill sorting is hard to grasp the incremental setting. Generally, we assume that the "increment" value is 4, 2, and 1. This is the general setting of hill sorting ). So here I want to draw up a formula for "increment" h (n + 1) = 3 * h (n) + 1, h> N/9) this formula may not be the most appropriate, but it is applicable to the general "increment" setting. If the number is 8, the increment here is 1.

Example programming:Int B [10] = {,} Sort its hill

// You need to select an appropriate method for self-incremental sorting by hill.

 
 

  
  
Void ShellSort (int B [10])
  
  
{
  
  
Int h, I;
  
  
Int n = 10;
  
  
// This loop is used to calculate the increment values 1 and 4.
  
  
For (h = 1; h <= n/9; h = 3 * h + 1 );
  
  
// Incremental Loop
  
  
For (; h> 0; h/= 3)
  
  
{
  
  
For (I = h; I 
  
  
{
  
  
Int j, temp;
  
  
Temp = B [I];
  
  
// Insert sorting
  
  
For (j = I-h; j> = 0; j = j-h)
  
  
{
  
  
If (B [j]> temp)
  
  
{
  
  
B [j + h] = B [j];
  
  
}
  
  
Else
  
  
{
  
  
Break;
  
  
}
  
  
}
  
  
B [j + h] = temp;
  
  
}
  
  
}
  
  
Cout <"the sort is :";
  
  
For (int I = 0; I <10; I ++)
  
  
{
  
  
Cout < 
  
  
}
  
  
Cout < 
  
  
}
 
 

Performance analysis:Time complexity is a little complicated for hill sorting. It varies according to the specific "increment". Here I use the O (n ^ 3/2) of Yan Weimin's "Data Structure)

Quick sorting

Usage conditions:A set of comparable sizes.

Algorithm idea:Sort the records to be sorted into two separate parts. If the keywords of one part of the records are smaller than those of the other, you can sort these two parts separately, finally, an ordered sequence is reached. The key point here is to select the "benchmark" for segmentation ". It must be more than this "benchmark" into a part, less than this "benchmark" into a part. Here, the first record of this part is taken as the "benchmark" by default ".

Example programming:Int B [10] =}

 
 

  
  
// Quick sorting
  
  
Void QuickSort (int * B, int low, int high)
  
  
{
  
  
// Exchange functions
  
  
Void Sawp (int * a, int * B );
  
  
Int Old_low = low;
  
  
Int Old_high = high;
  
  
While (low 
  
  
{
  
  
While (* (B + high)> * (B + low) & low 
  
  
Sawp (B + low, B + high );
  
  
While (* (B + low) <* (B + high) & low 
  
  
Sawp (B + low, B + high );
  
  
}
  
  
If (Old_low 
  
  
{
  
  
QuickSort (B, Old_low, low-1 );
  
  
}
  
  
If (high + 1 
  
  
{
  
  
QuickSort (B, high + 1, Old_high );
  
  
}
  
  
}
  
  
// Exchange functions
  
  
Void Sawp (int * a, int * B)
  
  
{
  
  
Int temp;
  
  
Temp = *;
  
  
* A = * B;
  
  
* B = temp;
  
  
}
 
 

Performance analysis:Time complexity O (nlogn)

At this point, we have introduced common basic data search and sorting algorithms, which are the most basic algorithms that can be extended by them.