for (int i = 0; i < len; ++i)
{
printf("%d ",arr[i] );
}
printf("\n");
return 0;
}
#include
int arr[10] = {9,8,7,6,5,4,3,2,1,0};
int tmp[10];
void Merge(int begin,int middle,int end)
{
int i = begin;
int j = middle + 1;
int k = begin;
while(i <= middle && j <= end)
{
if (arr[i] <= arr[j] )
{
tmp[k++] = arr[i++];
}
else
{
tmp[k++] = arr[j++];
}
}
while(i <= middle)
{
tmp[k++] = arr[i++];
}
while(j <= end)
{
tmp[k++] = arr[j++];
}
for (k = begin; k <= end; ++k)
{
arr[k] = tmp[k];
}
}
void MergeSort(int begin,int end)
{
if (begin < end)
{
int middle = (begin + end) / 2;
MergeSort(begin,middle);
MergeSort(middle + 1,end);
Merge(begin,middle,end);
}
}
int main(int argc, char const *argv[])
{
int len = sizeof(arr)/sizeof(int);
for (int i = 0; i < len; ++i)
{
printf("%d ",arr[i] );
}
printf("\n");
MergeSort(0,len - 1);
for (int i = 0; i < len; ++i)
{
printf("%d ",arr[i] );
}
printf("\n");
return 0;
}
快速排序：
快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
算法步骤：
一趟快速排序的算法是：
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索（j -- ），找到第一个小于key的值A[j]，A[i]与A[j]交换；
4）从i开始向后搜索，即由前开始向后搜索（i ++ ），找到第一个大于key的A[i]，A[i]与A[j]交换；
5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。
例如：
待排序的数组A的值分别是：（初始关键数据：key=49） 注意关键key永远不变，永远是和key进行比较，无论在什么位置，最后的目的就是把key放在中间，小的放前面大的放后面。
A[0] A[1] A[2] A[3] A[4] A[5] A[6]
49 38 65 97 76 13 27
进行第一次交换后：27 38 65 97 76 13 49
( 按照算法的第三步从后面开始找，此时:J=6）
进行第二次交换后：27 38 49 97 76 13 65
( 按照算法的第四步从前面开始找>key的值，65>49,两者交换，此时：I=2 )
进行第三次交换后：27 38 13 97 76 49 65
( 按照算法的第五步将又一次执行算法的第三步从后开始找
进行第四次交换后：27 38 13 49 76 97 65
( 按照算法的第四步从前面开始找大于key的值，97>49，两者交换，此时：I=3,J=5 )
此时再执行第三和四步的时候就发现i=J=4，从而结束一趟快速排序，那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所有大于key49的数全部在49的后面，所有小于key（49）的数全部在key（49）的前面。
时间复杂度：
快速排序每次将待排序数组分为两个部分，在理想状况下，每一次都将待排序数组划分成等长两个部分，则需要logn次划分。而在最坏情况下，即数组已经有序或大致有序的情况下，每次划分只能减少一个元素，快速排序将不幸退化为冒泡排序，所以快速排序时间复杂度下界为O(nlogn)，最坏情况为O(n^2)。在实际应用中，快速排序的平均时间复杂度为O(nlogn)。
空间复杂度：
快速排序需要一个额外的空间存储关键元素（pivot element）,因此空间复杂度为O(1)。
算法稳定性：
快速排序不稳定，且是在关键元素和某个元素发生交换时导致稳定性被破坏，比如序列5 3 3 4 3 8 9 10 11， 现在中枢元素5和3(第5个元素，下标从1开始计)交换就会破坏元素3的稳定性。
[cpp]
#include
#include
#include
void swap(int *a,int *b)
{
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
int partition(int *arr,int low,int high)
{
int pivot = arr[low];
while(low < high)
{
while(low < high && arr[high] >= pivot)
{
high--;
}
if (low < high)
{
swap(&arr[low],&arr[high]);
low++;
}
while(low < high && arr[low] <= pivot)
{
low++;
}
if(low < high)
{
swap(&arr[low],&arr[high]);
high--;
}
}
return low;
}
void quickSort(int *arr,int low,int high)
{
int pivotpos;
if (low < high)
{
pivotpos = partition(arr,low,high);
quickSort(arr,low,pivotpos-1);
quickSort(arr,pivotpos+1,high);
}
}
int main(int argc, char const *argv[])
{
int n ;
printf("please input the length of arr:\n");
scanf("%d",&n);
//int *arr = (int*)malloc(n * sizeof(int));
int arr[n];
printf("please input %d numbers for each elements\n", n);
for(int i = 0; i < n; i++)
{
scanf("%d",&arr[i]);
}