Shulou(Shulou.com)06/02 Report--

Today, I will talk to you about how to compare the six internal sorting algorithms of the data structure, which may not be well understood by many people. in order to make you understand better, the editor has summarized the following contents for you. I hope you can get something from this article.

1. Demand analysis

(1) the form of input data is as follows: pseudo-random number generation program is generated, and the number of inputs is not less than 100 at a time, at least 5 different sets of input data are needed.

(2) the output is in the form of outputting the data of the number of comparisons and the number of keyword movements (keyword exchange counts as 3 moves).

(3) the functions that the program can achieve: compare the six commonly used internal sorting algorithms: blistering sorting, direct insertion sorting, simple selection sorting, quick sorting, Hill sorting and heap sorting. The indicators of the comparison are the number of comparisons of keyword participation and the number of keyword movements (keyword exchange counts as 3 moves).

(4) Test data: the correct input is the pseudo-random number generation program to generate 100 random numbers, and then output the comparison results. The error input is a very small amount of input data, and the output results cannot be compared at this time.

(5) C language programming

2. Outline design

This program designs a sequence table structure to store the data that needs to be sorted. After the main program runs, initialize six sequence tables first, and then enter a large cycle that requires five cycles. In the cycle, there is a small cycle that needs to be executed 100times to generate 100random numbers to six sequence tables. At this time, the data of the six sequence tables are the same and are random numbers, and then call void InsertSort (SqList * L) to sort bubbles respectively. Void InsertSort (SqList * L) directly inserts sort, void SelectSort (SqList * L) simple selection sort, void QuickSort (SqList * L) quick sort, void ShellSort (SqList * L) Hill sort, void HeapSort (SqList * L) heap sort, to treat sort sort. In the modules of void InsertSort (SqList * L), void SelectSort (SqList * L) and void HeapSort (SqList * L), the void swap (SqList * L) module is called when the two data need to be exchanged. In the void HeapSort (SqList * L) module, void HeapAdjust (SqList * L) is called so that L-> r [1... I-1] is re-adjusted to a large top heap. In the void QuickSort (SqList * L) module, void QSort (SqList * L) is called to quickly sort the subsequence L-> r [low..high] in the order table L, and int Partition (SqList * L low,int high,int & k low..high) is called in the void QSort (SqList * L) to divide the L-> r [low..high] into two and calculate the pivot value.

3. Detailed design

In the sequential table structure, there are arrays for storing sort data of type int, r [0] as sentinel or temporary variables, and length variables of type int for recording sequential tables.

Typedef struct {

Int r [MAXSIZE+1]

Int length

} SqList

4. Debugging and analysis

(1) problems encountered during debugging:

1. When random numbers are generated at the beginning, values are assigned to the array of the ordered table. When the results come out, the first number is not sorted, and the other numbers are normal, because r [0] is used as a sentinel or stores temporary variables, so r [0] should not be assigned at the beginning of assignment.

2. When calculating the number of keyword exchanges, the defined variable is int l; after the calculation results, the number is very large. Because for a local variable, if no initial value is assigned, it actually stores a random value instead of 0, so it should be defined as int l = 0.

3. When calculating the comparison and exchange of keywords, because the modules have to call each other, the calculated value should be transmitted as a parameter, but when it is returned, it can not return two return values, which has been perplexed for a long time, and then the problem is solved by using int & k pencil int & l, that is, the method that can change the argument.

(2) time and space analysis of the algorithm:

Ranking method average time worst case stability extra space remarks

Bubbling O (n 2) O (n 2) is better to stabilize O (1) n hours.

It is better to choose O (N2) O (N2) unstable O (1) n hours.

Inserting O (nlogn) O (N2) stable O (1) is better when most of them have been sorted

Hill O (n ^ 1.5) unknown unstable O (1)

Fast O (nlogn) O (N2) unstable O (nlogn) n is better when it is large.

Pile O (nlogn) O (nlogn) unstable O (1) n is better when it is large.

Bubble sorting optimization: when the sequence has not been compared but has been ordered, actually do not continue the following loop judgment work, so add a scalar flag to achieve the improvement of this algorithm

Void BubbleSort2 (SqList * L) {

Int i,j

Status flag = TRUE

For (I = 1 × length & & flag;i++) {

Flag = FALSE

For (j = L-> length;j > = ibot jmure -) {

If (L-> r [j] > L-> r [juni1]) {

Swap (LMagneJJ Jockey 1)

Flag = TRUE

}

}

}

}

(3) experience: before you start typing the code, you should sort out your thoughts, find the best entry to write the code, and conceive the calls between modules first, otherwise there will be too much confusion between the later codes. When bug appears, it will be very difficult to find, and you should make full use of the functions of debugging.

5. User instructions

It is impossible for users to enter 100 numbers in this program. Therefore, after the execution of this program, random numbers will be generated automatically. The result of direct comparison will be displayed automatically. Easy to use, just run it directly.

6. Test results

From the tested data, we can see that the comparison times of keywords in bubble sort and simple sort are the same and will not fluctuate, this is because no matter the number of data changes, as long as the total number remains the same, both bubble sort and simple sort execute the comparison statement in the loop. In simple sorting, the movement of keywords is the least and the fluctuation is small, because the direct insertion sorting inserts the records directly from the disordered area to the ordered area, so there is no exchange of data, so the number of moves is less, but the number of comparisons is more. There is little difference between the number of comparisons and moves in heap sorting because the maximum value will be frequently compared to the end and then swapped in heap sorting. The number of movement of keywords in Hill sorting and fast ranking fluctuates greatly. It is because the action of exchanging positions between the two sorts of data is larger, so when the data is chaotic and neat, the result of the number of moves will be quite different.

5. Appendix

# include

# include

# define MAXSIZE 100

/ / order table structure for sorting

Typedef struct {

Int r [MAXSIZE+1]; / / is used to store the array to be sorted, and r [0] is used as a sentry or temporary variable

Int length

} SqList

/ / swap two values

Void swap (SqList * L _ menint I _ mint j) {

Int temp = L-> r [I]

L-> r [I] = L-> r [j]

L-> r [j] = temp

}

/ / Bubble sort

Void BubbleSort (SqList * L) {

Int iMagnedjrew0pc0pr lumb0jjrejrejjjjjre0pr

For (I = 1) {/ / outer loop, make sure that all numbers are compared with other numbers.

/ / karma +

For (j = inumber1bot) {/ / inner loop, using one number to compare the size with other numbers.

Kicking +

If (L-> r [I] > L-> r [j]) {

Swap (LMagna iMagnej)

L = lumb3

}

}

}

Printf ("the number of keyword comparisons in bubble sort is% d:", k)

Printf ("\ nThe number of moves of keywords in bubble sorting is% d:", l)

Printf ("\ n")

}

/ / sort directly

Void InsertSort (SqList * L) {

Int iMagnedjrew0pc0pr lumb0jjrejrejjjjjre0pr

For (I = 2) {

Kicking +

If (L-> r [I]

R [I-1]) {

L-> r [0] = L-> r [I]; / / set up sentinels

Lumped +

For (j = iMel 1bot L-> r [j] > L-> r [0]; JMY -) {

L-> r [jacks 1] = L-> r [j]; / / the record moves back

Lumped +

Kicking +

}

This step is easy to ignore. When you jump out of the cycle, you make a comparison and do not meet the requirements before you jump out.

L-> r [jacks 1] = L-> r [0]; / / insert into the correct location

Lumped +

}

}

Printf ("comparison of keywords in direct sorting is% d:", k)

Printf ("\ nThe number of moves of keywords in direct sorting is% d:", l)

Printf ("\ n")

}

/ / simple selection sort

Void SelectSort (SqList * L) {

Int i,j,min

Int karma 0, dint 0,

For (I = 1) {

/ / karma +

Min = I

For (j = iaccoun1wittjogthinto +) {

Kicking +

If (L-> r [min] > L-> r [j]) {

Min = j

}

}

If (I! = min) {/ / judge itemmin, then it is proved that there is data smaller than r [min], then it needs to be exchanged.

Swap (LMagna I min)

L = lumb3

}

}

Printf ("comparison number of keywords in simple sort is:% d", k)

Printf ("\ nThe number of moves of keywords in simple sorting is:% d", l)

Printf ("\ n")

}

/ / Hill sort

Void ShellSort (SqList * L) {

Int i,j

Int k = 0BI l = 0

Int increment = L-> length

Do {

Increment = increment/5+1;// incremental sequence

For (I = increment+1;ilength;i++) {

Kicking +

If (L-> r [I]

R [i-increment]) {/ / need to insert L-> r [I] into the ordered increment quantum table

L-> r [0] = L-> r [I]

Lumped +

For (j = I murmur increment L-> r [0] r [j] & & j > 0 politics j = j-increment) {

Kicking +

L-> r [j+increment] = L-> r [j]

Lumped +

}

This step is easy to ignore. When you jump out of the cycle, you make a comparison and do not meet the requirements before you jump out.

L-> r [j+increment] = L-> r [0]

Lumped +

}

}

} while (increment > 1)

Printf ("comparison number of keywords in Hill sort is:% d", k)

Printf ("\ nThe number of moves of keywords in Hill sorting is:% d", l)

Printf ("\ n")

}

/ / it is known that the keywords recorded in L-> r [s] satisfy the definition of heap except L-> r [s].

/ / this function adjusts the keywords of L-> r [s] to make L-> r [s] a large top heap.

Void HeapAdjust (SqList * L _ line int s _ r _ int _ m _ int & a _ _ int & b) {

Int temp,j

Temp = L-> r [s]

Baked +

For (j = 2 accountabiljr [j]

R [juni1] & & j = L-> r [j])

Break

L-> r [s] = L-> r [j]

Baked +

S = j

}

L-> r [s] = temp

Baked +

}

/ / Heap sort

Void HeapSort (SqList * L) {

Int i

Int k = 0BI l = 0

For (I = L-> length/2;i > 0Traci -) {/ / build r in L into a large top heap

HeapAdjust (LMagna iMagna L-> length,k,l)

}

For (I = L-> length;i > 1bot imuri -) {

Swap (LJEI) / / swaps the heap top record with the last record of the current unsorted subsequence

L = lumb3

HeapAdjust / re-adjust L-> r [1... I-1] to large top heap.

}

Printf ("number of key comparisons in heap sort is:% d", k)

Printf ("\ nThe number of moves of keywords in the heap sort is:% d", l)

Printf ("\ n")

}

/ / swap the records of the sequence table L sub-table so that the pivot records are in place and return to their location.

/ / at this time, the records before (after) it are not much (smaller) than it.

Int Partition (SqList * L Mint low,int high,int & k Mint & l) {

Int pivotkey

Pivotkey = L-> r [low]

While (lowr [high] > = pivotkey & & lowr [low] length,k,l)

Printf ("comparison number of keywords in quick sort is:% d", k)

Printf ("\ nThe number of moves of keywords in quick sort is:% d", l)

Printf ("\ n")

}

Int main () {

Int x,y

SqList L,L1,L2,L3,L4,L5

L.length = 100

For (int I = 0 position I)

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.