# sort

## The concept and application of sorting

### Sorting concept

==Sorting: = = the so-called sorting is the operation of arranging a string of records incrementally or decrementally according to the size of one or some keywords.

==Stability: = = if there are multiple records with the same keyword in the record sequence to be sorted, the relative order of these records remains unchanged after sorting, that is, in the original sequence, r[i]=r[j], and r[i] is before r[j], but in the sorted sequence, r[i] is still before r[j], then this sorting algorithm is said to be stable; Otherwise, it is called unstable.

==Internal sorting: = = sorting in which all data elements are placed in memory.

==External sorting: = = too many data elements can not be placed in memory at the same time. According to the requirements of sorting process, the sorting of data can not be moved between internal and external memory.

### Sorting application

#### Come to Jingdong

#### University Ranking

## Common sorting algorithms

## Implementation of common sorting algorithms

#### Insert sort

##### basic thought

Direct insertion sort is a simple insertion sort method. Its basic idea is to insert the records to be sorted into an ordered sequence one by one according to the size of their key values, until all records are inserted, and a new ordered sequence is obtained.

In practice, when we play cards, we use the idea of insertion sorting

##### But the array is definitely not ordered, so we have to order the array first

#### First peel out the print array

// Print array void PrintArray(int* a, int n) { assert(a); int i = 0; for (i = 0; i < n; i++) { printf("%d ", a[i]); } printf("\n"); }

#### Insert sort

// Insert sort void InsertSort(int* a, int n) { assert(a); int i = 0; for (i = 0; i < n - 1; i++) { int end = i; int x = a[end+1]; while (end >= 0) { //If the number to be inserted is smaller than the number in the sequence, prepare to move the position if (a[end] > x) { a[end + 1] = a[end]; end--; } else { //If the number inserted is larger than that in the sequence, it will jump out break; } } //Jump out of two situations //1.end == -1 //2.break //Give x to the one in front of end a[end + 1] = x; } }

Time complexity of insertion sort: O(N2)

Best: O(N) - sequential (near sequential)

Worst case: O(N2) - reverse order

Space complexity of insert sort: O(1)

#### Hill sort (reduced incremental sort) (Hill's force anyway)

Hill sort is optimizing direct insertion sort, and the effect is super obvious. Why optimization? Because we know that direct insertion sort will be very fast when it is close to order. Then I will create such an order to make its time complexity close to O(N). We know that the best time complexity of sorting is O(N), and our approach to O(N) is quite great, Almost close to the ceiling

Hill ranking method is also known as reduced incremental method. The basic idea of hill sorting method is to select an integer first, divide all records in the file to be sorted into groups, divide all records with distance into the same group, and sort the records in each group. Then, take and repeat the above grouping and sorting. When arrival = 1, all records are arranged in a unified group.

##### Hill sort step

1. Group pre sorting - the array is close to order

Group by gap, insert and sort the grouping values, and divide them into gap groups

2. The direct insertion sort array is close to order, and the time complexity of direct insertion is O(N)

###### Single group multi lying

###### Multi group insertion

Time complexity O(gap*(1 +... + N/gap))

Best: O(N)

Best: O(N)

Worst case: O(gap*(1 +... + N/gap))

The larger the gap, the faster the pre scheduling, and the less ordered the pre scheduling

The smaller the gap, the slower the pre scheduling, and the closer to order after pre scheduling

###### Stew in one pot in multiple groups (we can also stew in one pot if it's troublesome to insert in groups)

###### Multiple pre sorting (gap > 1) + direct insertion (gap == 1)

gap/2

gap/3

Time complexity O(N1.3) just remember. Anyway, remember that hill is very powerful, and Hill sorting is very fast

# Test the performance of direct insertion sort and Hill sort (let's see what Hill sort is)

## code

### Sort.h

#pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <time.h> // Interface for sorting implementation // Print array extern void PrintArray(int* a, int n); // Insert sort extern void InsertSort(int* a, int n); // Shell Sort extern void ShellSort(int* a, int n); // Select sort extern void SelectSort(int* a, int n); // Heap sort extern void AdjustDwon(int* a, int n, int root); extern void HeapSort(int* a, int n); // Bubble sorting extern void BubbleSort(int* a, int n); // Recursive implementation of quick sort // Quick sort hoare version extern int PartSort1(int* a, int left, int right); // Quick sequencing excavation method extern int PartSort2(int* a, int left, int right); // Quick sort before and after pointer method extern int PartSort3(int* a, int left, int right); extern void QuickSort(int* a, int left, int right); // Non recursive implementation of quick sort extern void QuickSortNonR(int* a, int left, int right); // Recursive implementation of merge sort extern void MergeSort(int* a, int n); // Non recursive implementation of merge sort extern void MergeSortNonR(int* a, int n); // Count sort extern void CountSort(int* a, int n);

### Sort.c

#define _CRT_SECURE_NO_WARNINGS 1 #include "Sort.h" // Print array void PrintArray(int* a, int n) { assert(a); int i = 0; for (i = 0; i < n; i++) { printf("%d ", a[i]); } printf("\n"); } // Insert sort void InsertSort(int* a, int n) { assert(a); int i = 0; for (i = 0; i < n - 1; i++) { int end = i; int x = a[end+1]; while (end >= 0) { //If the number to be inserted is smaller than the number in the sequence, prepare to move the position if (a[end] > x) { a[end + 1] = a[end]; end--; } else { //If the number inserted is larger than that in the sequence, it will jump out break; } } //Jump out of two situations //1.end == -1 //2.break //Give x to the one in front of end a[end + 1] = x; } } // Shell Sort void ShellSort(int* a, int n) { //grouping int gap = n; //Multiple pre sorting (gap > 1) + direct insertion (gap == 1) while (gap>1){ //gap /= 2; //Divided by three, we know that we don't have to pass 1, so we + 1 let him have a condition that he must pass 1 gap = gap / 3 + 1; //Single group multi lying int i = 0; for (i = 0; i < n - gap; i++) { int end = i; int x = a[end + gap]; while (end >= 0) { if (a[end] > x) { a[end + gap] = a[end]; //The step size is gap end -= gap; } else { break; } } a[end + gap] = x; } } }

### test.c

#define _CRT_SECURE_NO_WARNINGS 1 #include "Sort.h" // Performance comparison of test sorting void TestOP() { //Set random start point srand(time(NULL)); //The size of the array to be created const int N = 100000; int* a1 = (int*)malloc(sizeof(int) * N); int* a2 = (int*)malloc(sizeof(int) * N); for (int i = 0; i < N; ++i) { //Ensure that the two arrays are the same a1[i] = rand(); a2[i] = a1[i]; } int begin1 = clock();//start time InsertSort(a1, N); int end1 = clock(); //End time int begin2 = clock(); ShellSort(a2, N); int end2 = clock(); int begin3 = clock(); printf("InsertSort:%d\n", end1 - begin1);//End time minus start time printf("ShellSort:%d\n", end2 - begin2); free(a1); free(a2); } //Test insert sort void TestInsertSort() { int a[] = { 1,5,3,7,0,9 }; InsertSort(a, sizeof(a) / sizeof(a[0])); PrintArray(a, sizeof(a) / sizeof(a[0])); } //Test Hill sort void TestShellSort() { int a[] = { 9,1,2,5,7,4,8,6,3,5 }; ShellSort(a, sizeof(a) / sizeof(a[0])); PrintArray(a, sizeof(a) / sizeof(a[0])); } int main(){ //TestInsertSort(); //TestShellSort(); TestOP(); return 0; }