面试中 各种排序算法实现

1：

快速排序法原理也是用了分治法，主要原理是将数组分为A[p..q-1] 和A[q+1..r]，然后调整元素使得A[p..q-1]小于等于q，也小于等于A[q+1..r]。然后不断的递归，到最后就排序完成。 

/*******************************************
* 快速排序模版 by hnust_xiehonghao *
* 2014.6.9.23.08 *
* 注意所有区间为[) 左闭右开 *
* *
*******************************************/
#include <stdio.h>
#include <string.h>

int sort(int a[], int left, int right)
{
int val = a[right - 1];
int temp;
int pos = left - 1;
if(left >= right) return left;
for(int i = left; i < right; i++)
{

if(a[i] <= val)
{
pos++;
temp = a[i];
a[i] =a[pos];
a[pos] = temp;
}
}
return pos;
}
void quick_sort(int a[], int left, int right)
{
if(left < right)
{
int pos = sort(a, left, right);
quick_sort(a, left, pos);
quick_sort(a, pos + 1, right);
}

}

int main()
{
int a[1111];
int len;
while(scanf("%d", &len) !=EOF)
{
for(int i = 0; i < len; i++)
{
scanf("%d", &a[i]);
}
quick_sort(a, 0, len);
for(i = 0; i< len ; i++) printf("%d ", a[i]);
}
return 0;
}

2  节省分配时间的归并排序

#include <stdio.h>
#include <string.h>

void merge(int a[], int left, int mid ,int right, int temp[])
{
int i = left, j = mid + 1, k = 0;

while( (i <= mid) && (j <= right) )
{
if(a[i] < a[j])
temp[k++] = a[i++];
else temp[k++] = a[j++];
}
while(i <= mid)
{
temp[k++] = a[i++];
}
while(j <= right)
{
temp[k++] = a[j++];
}
k = 0;
for(i=left;i<=right;i++)
{
a[i] = temp[k++];
}

}
void merge_sort(int a[], int left ,int right, int temp[])
{
int mid;
if(left < right)
{
mid = (left + right) / 2;
merge_sort(a, left, mid, temp);
merge_sort(a, mid+1, right, temp);
merge(a, left, mid, right, temp);
}
}
int main(void)
{
int a[10] = {1, 3, 4, 5, 3, 6, 43, 32, 6};
int *p = new int [10];
merge_sort(a, 0, 9, p);
delete []p;
for(int i = 0 ;i < 10; i++)
printf("%d\n", a[i]);
return 0;
}

 

/*
3 堆排序
① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区
② 再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R
交换，由此得到新的无序区R[1..n-1]和有序区R
，且满足R[1..n-1].keys≤R
.key
③ 由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。
……
直到无序区只有一个元素为止。

*/

#include <stdio.h>
int arr[111];
void AdjustHeap(int nd, int n) //  最小堆
{
int  slt;
int temp;
while(nd*2 <= n)
{
slt = nd*2;
if(nd*2+1 <= n && arr[nd*2]>arr[nd*2+1])//选中左，右子树中较小的一个
slt = nd*2+1;
if(arr[nd] > arr[slt])
{
temp = arr[nd];
arr[nd] = arr[slt];
arr[slt] = temp;

nd = slt;
}
else break;
}
}

void HeapSort(int n)
{
int nd ,i;
for (nd = (n + 1)/2; nd >= 1; nd--)
{
AdjustHeap(nd , n);
}
for(i = n; i > 1; i--)
{
int temp = arr[i];
arr[i] = arr[1];
arr[1] = temp;
AdjustHeap(1, i-1);
}
}
int main()
{
int   n ,i;
while(scanf("%d" ,&n)!=EOF)
{
if(!n) break;
for (i = 1; i <= n; i++)
{
scanf("%d", &arr[i]);

}
HeapSort(n);
for(i = 1 ;i <n; i++)
{
printf("%d ", arr[i]);
}
printf("%d\n", arr[i]);
}
return 0;
}

参考http://blog.csdn.net/wolinxuebin/article/details/7456330

<pre code_snippet_id="261822" snippet_file_name="blog_20140419_3_7342767" class="cpp" name="code"><pre code_snippet_id="261822" snippet_file_name="blog_20140419_3_7342767">