各种排序算法及其优劣

排序算法优劣的衡量标准

时间代价(最大时间代价，最小时间代价，平均时间代价)：记录的移动和比较次数
空间代价,算法自身的复杂程度

1. 直接插入排序：空间代价O(1)；时间代价O(n^2)；该稳定排序。

int InsertSort(int arr[], int n)
{
int temp = 0;
int j = 0;
for (int i = 1; i < n; i++)
{
temp = arr[i]; //待插入元素赋值给temp
j = i - 1; //从当前位置往前寻找i的正确位置
while (j >= 0 && arr[j]>temp)
{
arr[j + 1] = arr[j];
i--;
}
arr[i + 1] = temp;
}
return 0;
}

2. 折半插入排序：用二分法查找第i个记录的正确位置元素预先有序,时间复杂度O(n^2)，该排序算法稳定。
int biInsertSort(int arr[], int n)
{
int left = 0, right = 0, mid = 0;
int p = 0;

int ShellSort(int arr[], int n)
{
int d = n / 2;   //增量为数组大小的一半
while (d >= 1)
{
for (int k = 0; k < d; k++)
{
for (int i = k + d; i < n; i += d)
{
int temp = arr[i];
int j = i - d;
while (j >= k&&arr[j]>temp)
{
arr[j + d] = arr[j];
j -= d;
}
arr[j + d] = temp;
}
}
d = d / 2;
}
return 0;
}

for (p = 1; p < n; p++){int temp = arr[p]; //保存待插入数据left = 0;right = p - 1;while (left <= right){mid = (left + right) / 2;if (arr[mid]>temp)right = mid - 1;elseleft = mid + 1;}for (int i = p - 1; i >= left; i--)arr[i + 1] = arr[i];arr[left] = temp;}return 0;}

3. 希尔排序：先将序列转化为若干小序列，在小序列内进行插入排序，然后逐渐扩大小序列的规模

减少序列个数，最终对整个序列进行插入排序完成排序

不稳定，空间代价：O(1);时间代价O(n)到O(n^2)，视增量序列而定
int ShellSort(int arr[], int n) { int d = n / 2; //增量为数组大小的一半 while (d >= 1) { for (int k = 0; k < d; k++) { for (int i = k + d; i < n; i += d) { int temp = arr[i]; int j = i - d; while (j >= k&&arr[j]>temp) { arr[j + d] = arr[j]; j -= d; } arr[j + d] = temp; } } d = d / 2; } return 0; }

4. 改进的冒泡排序

稳定性：稳定   空间代价分析：O(1)  时间代价分析：O(n^2)
int BubbleSort(int arr[], int n)
{
int flag = 0; //标记每一趟排序过程中是否发生了交换
for (int i = 0; i < n; i++)
{
flag = 0;
for (int j = 0;j < n - i; j++)
{
if (arr[j] < arr[j - 1])
{
flag = 1;
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
if (flag == 0)
return 0;
}
return 0;
}

5. 快速排序（分治法）

平均时间空间代价均为：O(log(n))
int Partition(int arr[], int left, int right)
{
int pivot = arr[left]; //选择最左边的为轴元素
while (left < right)
{
while (left<right&&arr[right]>pivot)
right--;
arr[left] = arr[right];
while (left<right&&arr[left]<=pivot)
left++;
arr[right] = arr[left];
}
arr[left] = pivot;
return left;
}
void QuickSort(int arr[], int left, int right)
{
if (left < right)
{
int p = Partition(arr, left, right);
QuickSort(arr, left, p - 1);
QuickSort(arr, p + 1, right);
}
}

6. 选择排序
int SelectionSort(int arr[], int n)

{
for (int i = 1; i < n; i++)
{
int k = i - 1;
for (int j = i; j < n; j++)
{
if (arr[j] < arr[j])
k = j;
}
if (k != i - 1)
{
int t = arr[k];
arr[k] = arr[i - 1];
arr[i - 1] = t;
}
}
return 0;

}