【21天学习挑战赛】希尔排序

​
​

活动地址：CSDN21天学习挑战赛
学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。

排序

基本概念

评价指标：

1. 稳定性：关键字相同的元素在排序后相对位置不变，但是稳定的算法一定比不稳定的好？不一定，要看实际需求
2. 复杂度：
   1. 时间复杂度
   2. 空间复杂度

分类：

1. 内部排序：关注如何使算法时间空间复杂度更低
2. 外部排序： 还需要关注如何使读写磁盘次数更少

内部排序

1. 插入类排序：
   1. 直接插入排序
   2. 折半插入排序
   3. 希尔排序
2. 交换排序
   1. 冒泡排序
   2. 快速排序
3. 选择排序
   1. 简单选择排序
   2. 堆排序
4. 归并排序
5. 基数排序

外部排序

希尔排序

思路过程

在排序的时候会设置一个d，每排序一次这个d就会减少，这个d是元素的间隔，最后间隔变为1，就让整个序列都有序了。

算法图解：

代码实现（c语言）

//希尔排序
void ShellSort(int* arr, int sz)
{
	int gap = sz;//设置排序的间隔
	while ( gap > 1 )
	{
	   //保证gap最后进来循环后为1，所以对此加1
		gap = gap / 3 + 1;//gap>1为与排序，gap==1，为直接插入排序
		
		for (int i = 0; i < sz - gap; i++)//并不是一次性把一组排完，而是挨个往后，一组一个轮流排
		{
			int end = i;
			int tmp = arr[end + gap];
			while (end >= 0)
			{
				if (tmp < arr[end])
				{
					arr[end + gap] = arr[end];
					end -= gap;
					count++;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tmp;
		}
	}
	printf("希尔插入排序后移次数count=%d", count);
}

希尔排序性能

实战演练

题目链接：剑指 Offer II 075. 数组相对排序

代码实现：

struct hashTable {
    int key;
    int val;
    UT_hash_handle hh;
};

struct hashTable* hashtable;

struct hashTable* find(int ikey) {
    struct hashTable* tmp;
    HASH_FIND_INT(hashtable, &ikey, tmp);
    return tmp;
}

void insert(int ikey, int ival) {
    struct hashTable* tmp = malloc(sizeof(struct hashTable));
    tmp->key = ikey, tmp->val = ival;
    HASH_ADD_INT(hashtable, key, tmp);
}

int cmp(void* _a, void* _b) {
    int a = *((int*)_a), b = *((int*)_b);
    struct hashTable *fa = find(a), *fb = find(b);
    if (fa == NULL) {
        return fb == NULL ? a - b : 1;
    } else {
        return fb == NULL ? -1 : fa->val - fb->val;
    }
}

int* relativeSortArray(int* arr1, int arr1Size, int* arr2, int arr2Size, int* returnSize) {
    hashtable = NULL;
    for (int i = 0; i < arr2Size; ++i) {
        insert(arr2[i], i);
    }
    qsort(arr1, arr1Size, sizeof(int), cmp);
    *returnSize = arr1Size;
    return arr1;
}