数据结构排序家族

void Swap(int* array, int i, int j)
{
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}

//时间复杂度：最坏O(n ^ 2) 平均O(n ^ 2) 最好O(n)
//空间复杂度：O(1)
//稳定性：稳定
//数据敏感：敏感
void insertSort(int* array, int n)
{
for (int i = 0; i < n - 1; ++i)
{
//有序序列的最后一个位置
int end = i;
//待插入的数据
int key = array[end + 1];
//找到第一个小于key的值
while (end >= 0 && array[end] > key)
{
//当前数据向后移动
array[end + 1] = array[end];
–end;
}
array[end + 1] = key;
}
}

/时间复杂度：最坏O(n ^ 1.3) 平均O(n ^ 1.3) 最好O(n)
空间复杂度：O(1)
稳定性：不稳定—>分组时相同值的元素不一定可以分到同一组，预排序是可能导致相对位置发生变化
数据敏感：敏感/
void shellSort(int* array, int n)
{
//步长
int gap = n;
//多轮
while (gap > 1)
{
gap = gap / 3 + 1;
//一轮
for (int i = 0; i < n - gap; ++i)
{
//组内进行排序
int end = i;
int key = array[end + gap];
while (end >= 0 && array[end] > key)
{
array[end + gap] = array[end];
//组内移动
end -= gap;
}
array[end + gap] = key;
}
}
}

/*
时间复杂度：最坏O(n^2) 平均O(n^2) 最好O(n^2)
空间复杂度：O(1)
稳定性：稳定
数据敏感：不敏感
*/

void selectSort(int* array, int n)
{
for (int i = 0; i < n; ++i)
{
//未排序数据的最左边
int start = i;
//最小值的位置
int min = start;
for (int j = start + 1; j < n; ++j)
{
if (array[j] < array[min])
min = j;
}
Swap(array, start, min);
}
}

void selectSort2(int* array, int n)
{
//开头
int begin = 0;
//结尾
int end = n - 1;
while (begin < end)
{
//每一次选择最大值和最小值
int min = begin, max = begin;
for (int i = begin + 1; i <= end; ++i)
{
//取大的时候，相同的值，选择后面的值
if (array[i] >= array[max])
max = i;
if (array[i] < array[min])
min = i;
}
//交换最小值
Swap(array, begin, min);
//更新最大值的位置
if (max == begin)
max = min;
//交换最大值
Swap(array, end, max);
++begin;
–end;
}
}

/*
时间复杂度：最坏O(n^2) 平均O(n^2) 最好O(n)
空间复杂度：O(1)
稳定性：稳定
数据敏感：敏感
*/

void bubbleSort(int* array, int n)
{
while (n)
{
//对于已经有序的序列，通过建立一个标签来提前结束排序
//flag = 1 表示在一轮排序中没有发生元素的交换
int flag = 1;
int end = n;
for (int i = 0; i < end - 1; ++i)
{
if (array[i] > array[i + 1])
{
Swap(array, i, i + 1);
flag = 0;
}
}
//如果 flag = 1 说明没有发生元素的位置交换
if (flag)
break;
–n;
}
}

/*
时间复杂度：O(nlogn)
空间复杂度：O(1)
稳定性：不稳定 --> 调整的过程中相对位置可能会发生变化
数据敏感：不敏感
*/

void shiftDown(int* array, int n, int parent)
{
int child = 2 * parent + 1;
while (child < n)
{
if (child + 1 < n && array[child + 1] > array[child])
++child;
if (array[child] > array[parent])
{
Swap(array, child, parent);
parent = child;
child = 2 * parent + 1;
}
else
break;
}

}
void heapSort(int* array, int n)
{
//建堆
for (int i = (n - 2) / 2; i >= 0; --i)
{
shiftDown(array, n, i);
}
//循环删除
while (n)
{
Swap(array, 0, n - 1);
–n;
shiftDown(array, n, 0);
}
}
//hoare法
int partion1(int* array, int begin, int end)
{
//选择基准值
int key = array[begin];
int start = begin;
while (begin < end)
{
//从后向前第一个小于key的位置
while (begin < end && array[end] >= key)
–end;
//从前向后第一个大于key的位置
while (begin < end && array[begin] <= key)
++begin;
//交换begin 和 end 的值
Swap(array, begin, end);
}
//交换 初始的值和 相遇位置的值
Swap(array, start, begin);

return begin;

}
//填坑法
int partion2(int* array, int begin, int end)
{
//第一个为基准值
int key = array[begin];
while (begin < end)
{
//从后向前找第一个小于基准值的位置
while (begin < end && array[end] >= key)
–end;
//填坑:begin
array[begin] = array[end];
while (begin < end && array[begin] <= key)
++begin;
//填坑：end
array[end] = array[begin];
}
//最后一个坑,前后相遇的位置，填充基准值
array[begin] = key;
//返回基准值的位置
return begin;

}

//前后指针法
int partion3(int* array, int begin, int end)
{
//prev是最后一个小于基准值的位置
int prev = begin;
//新发现的下一个小于基准值的位置
int cur = prev + 1;
int key = array[begin];
while (cur <= end)
{
//不连续
if (array[cur] < key && ++prev != cur)
Swap(array, prev, cur);
++cur;
}
Swap(array, begin, prev);

return prev;

}

/*
时间复杂度：最坏：O(n^2)–>不会出现 最好:O(nlogn) 平均：O(nlogn)
空间复杂度：O(logn) 函数调用栈， 极端情况: O(n)–>不会出现
稳定性：不稳定
数据敏感：敏感
*/

//递归
void quickSort(int* array, int begin, int end)
{
if (begin >= end)
return;
//int keyPos = partion1(array, begin, end);
//int keyPos = partion2(array, begin, end);
int keyPos = partion3(array, begin, end);

//划分左边的区间
quickSort(array, begin, keyPos - 1);
//划分右边的区间
quickSort(array, keyPos + 1, end);

}

void merge(int* array, int begin, int mid, int end, int* tmp)
{
int begin1 = begin, end1 = mid, begin2 = mid + 1, end2 = end;
int idx = begin;
//合并
while (begin1 <= end1 && begin2 <= end2)
{
if (array[begin1] <= array[begin2])
tmp[idx++] = array[begin1++];
else
tmp[idx++] = array[begin2++];
}
//查看是否有剩余元素
if (begin1 < end1)
memcpy(tmp + idx, array + begin1, sizeof(int) * (end1 - begin1 + 1));
if (begin2 < end2)
memcpy(tmp + idx, array + begin2, sizeof(int) * (end2 - begin2 + 1));
//拷贝到原始空间
memcpy(array + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}

void mergeSortR(int* array, int begin, int end, int* tmp)
{
if (begin >= end)
return;

int mid = begin + (end - begin) / 2;

//保证子序列有序
mergeSortR(array, begin, mid, tmp);
mergeSortR(array, mid + 1, end, tmp);
//合并
merge(array, begin, mid, end, tmp);

}

/*时间复杂度：O（nlogn)
空间复杂度：O(n)
稳定性：稳定
敏感性：不敏感
*/

void mergeSort(int* array, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);

mergeSortR(array, 0, n - 1, tmp);
free(tmp);

}

void mergeSortNOR(int* array, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
//待归并区间的元素个数
int k = 1;
//多轮归并
while (k < n)
{
//一轮归并
for (int i = 0; i < n; i += 2 * k;)
{
int begin = i;
int mid = i + k - 1;
//判断mid是否越界
if (mid >= n - 1)
continue;
int end = i + 2 * k - 1;
//判断end是否越界
if (end >= n)
end = n - 1;
merge(array, begin, mid, end, tmp);
}
//2的指数
k *= 2;
}

}