Several basic insertion sorts

1. Insert Sort
Insert sort (Insertion sort) is a simple and intuitive sorting algorithm. It works by constructing an ordered sequence, for unsorted data, to scan from backward forward in the sorted sequence, to find the appropriate position and insert it. The insertion sort is implemented on an implementation, usually in the order of In-place (that is, the ordering of extra space using only O (1), so that in the backward-forward scanning process, the ordered elements need to be moved back and forth gradually, providing the insertion space for the newest elements.
Time complexity: O (n^2);
Algorithm Description:
1. Starting with the first element, the element can be thought to have been sorted
2. Take the next element and scan from the back forward in the sequence of ordered elements
3. If the element (sorted) is greater than the new element, move the element to the next position
4. Repeat step 3 until the sorted element is found to be less than or equal to the position of the new element
5. After inserting a new element into the location
6. Repeat steps 2~5
Animated Demo :

Swfung8
Algorithm Demo:

2. /*
4. * * Direct Insert Sort
6. */
8. void Insertsort (int a[], int len)
10. {
12. int I, j, key;
14. for (i = 1; i < Len; ++i) {
16. key = A[i];
18. for (j = i-1; J >=0;--j) {
20. if (A[j] > key)
22. A[J+1] = A[j];
24. Else
26. Break
28. }
30. A[J+1] = key;
32. }
34. }

2. Binary Insert Sort
Binary Insert sort (binary insertion sort) is an improvement to the insertion sorting algorithm, which is the process of sequentially inserting elements into sequential sequences. Time complexity O (n^2);
Algorithm Description:
In the process of inserting a new element into an ordered array, when looking for the insertion point, set the first element of the insertion area to A[low] and the end element to A[high], then the wheel will be inserted into the element with A[m], where m= (Low+high)/2 is compared, if larger than the reference element, Select A[low] to a[m-1] for the new insert area (i.e. high=m-1), otherwise select a[m+1] to A[high] for the new insert area (i.e. low=m+1), so that until the Low<=high is not established, all elements after this position will be moved back one bit, and insert the new element into the a[high+1]
Algorithm Demo:

2. /*
4. * * Binary Insert Sort
6. */
8. void Binsertsort (int a[], int len)
10. {
12. int I, J;
14. int low, high, mid;
16. int key;
18. for (i = 1; i < Len; i++) {
20. key = A[i];
22. low = 1; High = i-1;
24. while (low <= high) {
26. Mid = (Low+high)/2;
28. if (Key < A[mid])
30. High = mid-1;
32. Else
34. low = mid+1;
36. }
38. for (j = i-1; J >=high+1;--j)
40. A[J+1] = A[j];
42. A[HIGH+1] = key;
44. }
46. }

3. Hill sort
The hill sort, also known as the descending incremental sorting algorithm, is an efficient and improved version of the insertion sort.
Hill sort is a kind of stable sorting algorithm, the time complexity is O (N^3/2);
The hill algorithm proposes an improved method based on the two-point nature of the insertion order:
* Insert sort the efficiency of the linear sequencing can be achieved when the data operation is almost well-arranged;
* But the insertion sort is generally inefficient because the insertion sort can only move the data one bit at a time;
Algorithm Description:
1. First take a positive integer d1 (D1 < n), divide all records into D1 groups, all records with a multiple of D1 are considered as a group, then insert sort within each group
2. Then take D2 (D2 < D1)
3. Repeat the above grouping and sorting operations until you take di = 1 (i >= 1) position, that is, all records become a group, and finally the group is inserted to sort. General election D1 is about N/2,D2 for D1/2, D3 for D2/2, ..., di = 1.
Animated Demo:
1. Suppose there are arrays a = [80, 93, 60, 12, 42, 30, 68, 85, 10], First Take D1 = 4, divide the array into 4 groups, such as the same color in the same group:

2. Then insert the order of 4 groups, and the result is:

3. Then, take d2 = 2 and divide the original array into 2 groups, such as:

4. Then insert the order of 2 groups, and the result is:

5. Finally, take d3 = 1 and get the final result after inserting the sort:

Algorithm Demo:

2. /*
4. * * Hill Sort
6. */
8. void Shellsort (int a[], int n)
10. {
12. int I, j, Gap;
16. for (gap = N/2; gap>0; gap/= 2)//step
18. for (i = 0; I < gap; ++i) {
20. for (j = i+gap; j<n;j+=gap) {
22. if (A[j] < A[j-gap]) {
24. int temp = A[j];
26. int k = J-gap;
28. while (k>=0 && a[k] > Temp) {
30. A[K+GAP] = a[k];
32. K-= gap;
34. }
36. A[K+GAP] = temp;
38. }
40. }
42. }
44. }

4.example Code:

2. int main ()
4. {
6. int i;
8. int a[] = {80, 93, 60, 12, 42, 30, 68, 85, 10};
12. Insertsort (A, sizeof (a)/sizeof (a[0]));
14. for (i = 0; i < sizeof (a)/sizeof (a[0]); ++i)
16. printf ("%d", a[i]);
18. printf ("\ n");
22. Binsertsort (A, sizeof (a)/sizeof (a[0]));
24. for (i = 0; i < sizeof (a)/sizeof (a[0]); ++i)
26. printf ("%d", a[i]);
28. printf ("\ n");
32. Shellsort (A, sizeof (a)/sizeof (a[0]));
34. for (i = 0; i < sizeof (a)/sizeof (a[0]); ++i)
36. printf ("%d", a[i]);
38. printf ("\ n");
42. return 0;
44. }

Several basic insertion sorts