【数据结构-排序问题】各种排序哦

这两天一直总结排序问题，然后话不多啦，直接上代码

最主要的是要学会快速排序和冒泡排序，其它排序要熟练即可。

#include<stdio.h>
#include<stdlib.h>
#define DataType int 
void InsertSort(DataType A[], DataType len);
void BiInsertSort(DataType A[], DataType len);
void BubbleSort1(DataType A[], DataType len);//冒泡排序（从右至左）
void BubbleSort2(DataType A[], DataType len);//冒泡排序(从左至右）
void FastSort(DataType A[], int left, int right);//快速排序
void SelectSort(DataType A[], int len);//选择排序
DataType main(void)
{
DataType *A = (DataType *)malloc(sizeof(DataType));
DataType key;
DataType i = 1;
A[0] = 0;
printf("请您随便输入数字，然后本程序对这些数字从小到大排序!按#结束\n");
while (scanf("%d", &key) == 1)
{
A[i] = key;
i++;
}
printf("排序后的结果是：\n");
//BiInsertSort(A, i - 1);
SelectSort(A, i - 1);
DataType k;
for (k = 1; k <= i - 1; k++)
printf("%d ", A[k]);
return 0;
}
//折半查找排序减少了比较次数为o(nlog2n),但是时间复杂度仍为o(n2),稳定排序（插入排序）
void BiInsertSort(DataType A[], DataType len)
{
DataType i, j, low, high, mid;
for (i = 2; i <= len; i++)
{
A[0] = A[i];
low = 1; high = i - 1;
while (low <= high)
{
mid = (low + high) / 2;
if (A[mid] > A[0])//这个大小符号的改变就是改变了排序顺序（>是从小到大排序，<是从大到小排序）
high = mid - 1;
else
low = mid + 1;
}
for (j = i - 1; j >= high + 1; --j)
{
A[j + 1] = A[j];
}
A[high + 1] = A[0];
}
}
//直接插入排序比较次数为o(n2),时间复杂度为o(n2)，稳定排序（插入排序）
void InsertSort(DataType A[], DataType len)
{
DataType i, j;
for (i = 2; i <= len; i++)
if (A[i] < A[i - 1])
{
A[0] = A[i];
for (j = i - 1; A[0] < A[j]; --j)
A[j + 1] = A[j];
A[j + 1] = A[0];
}
}
//从右至左的冒泡（外部循环从左至右，内部循环从右至左）复杂度（o(n2))，稳定( 交换排序）
void BubbleSort1(DataType A[], DataType len)
{
int i, j;
bool flag;
for (i = 1; i <= len; i++)
{
flag = false;
for (j = len; j >i; j--)
{
if (A[j - 1] > A[j])
{
A[0] = A[j - 1];
A[j - 1] = A[j];
A[j] = A[0];
flag = true;
}
}
if (flag == false)
break;
}
}
//从左至右的冒泡（外部循环从右至左，内部循环从左至右）( 交换排序）
void BubbleSort2(DataType A[], DataType len)
{
int i, j;
bool flag;
for (i = len; i >= 1; i--)
{
flag = false;
for (j = 1; j <i; j++)
{
if (A[j] > A[j + 1])
{
A[0] = A[j];
A[j] = A[j + 1];
A[j + 1] = A[0];
flag = true;
}
}
if (flag == false)
break;
}
}
int partition(DataType A[], int left, int right)
{
int pivot = A[left];
while (left < right)
{
if ((left<right) && (A[right] >= pivot))
--right;
A[left] = A[right];
if ((left < right) && A[left] <= pivot)
++left;
A[right] = A[left];
}
A[left] = pivot;
return left;
}
//快速排序，平均时间复杂度o(nlog2n),最好为o(log2n),最坏为o(n2).是不稳定排序( 交换排序）
void FastSort(DataType A[], int left, int right)
{
if (left < right)
{
int pivotloc = partition(A, left, right);
FastSort(A, pivotloc + 1, right);
FastSort(A, left, pivotloc - 1);
}


}
//简单选择排序，不稳定，o(n2)（选择排序）
void SelectSort(DataType A[], int len)
{
int i, j;
int min;
for (i = 1; i <= len; i++)
{
min = i;
for (j = i + 1; j <= len; j++)
{
if (A[j] < A[min])
min = j;
}
if (min != i)
{
int temp = A[i];
A[i] = A[min];
A[min] = temp;
}


}
}