算法导论代码 第7章 快速排序

第7章 快速排序

7.1 快速排序的描述

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
void swap(void *a, void *b, size_t elem_size)
{
	if(a==NULL||b==NULL||a==b)
		return;
	char temp[elem_size];	/*变长数组 */
	memcpy(temp, a, elem_size);
	memcpy(a, b, elem_size);
	memcpy(b, temp, elem_size);
}
int partition(void *base, size_t elem_size, int p, int r,
	      int (*comp) (const void *, const void *))
{
	char *cbase = base;
	void *key = &cbase[r * elem_size];
	int i = p - 1;
	for (int j = p; j < r; j++) {
		if (comp(&cbase[j * elem_size], key) <= 0) {
			++i;
			swap(&cbase[i * elem_size], &cbase[j * elem_size], elem_size);
		}
	}
	swap(&cbase[(i + 1) * elem_size], key, elem_size);
	return i + 1;
}

void quick_sort(void *base, size_t elem_size, int p, int r,
	       int (*comp) (const void *, const void *))
{
	if (p < r) {
		int q = partition(base, elem_size, p, r, comp);
		quick_sort(base, elem_size, p, q - 1, comp);
		quick_sort(base, elem_size, q + 1, r, comp);
	}
}

void randomized_in_place(void *array, size_t elem_size, int length)
{
	char *carray = array;
	for (int i = 0; i < length; i++) {
		int rand_index = rand() % (length - i) + i;
		swap(&carray[i * elem_size], &carray[rand_index * elem_size],
		     elem_size);
	}
}

void print_array(int a[], int length)
{
	for (int i = 0; i < length; i++) {
		printf("%d ", a[i]);
	}
	printf("\n");
}

int cmp_int(const void *p1, const void *p2)
{
	const int *pa = p1;
	const int *pb = p2;
	if (*pa < *pb)
		return -1;
	if (*pa == *pb)
		return 0;
	return 1;
}
int main(void)
{
	srand((unsigned)time(NULL));
	int a[10];
	for (int i = 0; i < 10; i++) {
		a[i] = i;
	}
	randomized_in_place(a, sizeof(int), 10);
	printf("排序前:\n");
	print_array(a, 10);
	quick_sort(a, sizeof(int), 0, 9, cmp_int);
	printf("排序后:\n");
	print_array(a, 10);
	return 0;
}

7.3 快速排序的随机化版本

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
void swap(void *a, void *b, size_t elem_size)
{
	if(a==NULL||b==NULL||a==b)
		return;
	char temp[elem_size];	/*变长数组 */
	memcpy(temp, a, elem_size);
	memcpy(a, b, elem_size);
	memcpy(b, temp, elem_size);
}
int partition(void *base, size_t elem_size, int p, int r,
	      int (*comp) (const void *, const void *))
{
	char *cbase = base;
	void *key = &cbase[r * elem_size];
	int i = p - 1;
	for (int j = p; j < r; j++) {
		if (comp(&cbase[j * elem_size], key) <= 0) {
			++i;
			swap(&cbase[i * elem_size], &cbase[j * elem_size], elem_size);
		}
	}
	swap(&cbase[(i + 1) * elem_size], key, elem_size);
	return i + 1;
}

int randomized_partition(void *base, size_t elem_size, int p, int r,
			int (*comp) (const void *, const void *))
{
	char *cbase = base;
	int i = rand() % (r - p + 1) + p;
	swap(&cbase[r * elem_size], &cbase[i * elem_size], elem_size);
	return partition(base, elem_size, p, r, comp);
}

void randomize_quick_sort(void *base, size_t elem_size, int p, int r,
			int (*comp) (const void *, const void *))
{
	if (p < r) {
		int q = randomized_partition(base, elem_size, p, r, comp);
		randomize_quick_sort(base, elem_size, p, q - 1, comp);
		randomize_quick_sort(base, elem_size, q + 1, r, comp);
	}
}

void randomized_in_place(void *array, size_t elem_size, int length)
{
	char *carray = array;
	for (int i = 0; i < length; i++) {
		int n_rand_index = rand() % (length - i) + i;
		swap(&carray[i * elem_size], &carray[n_rand_index * elem_size],
		     elem_size);
	}
}

void print_array(int a[], int length)
{
	for (int i = 0; i < length; i++) {
		printf("%d ", a[i]);
	}
	printf("\n");
}

int cmp_int(const void *p1, const void *p2)
{
	const int *pa = p1;
	const int *pb = p2;
	if (*pa < *pb)
		return -1;
	if (*pa == *pb)
		return 0;
	return 1;
}
int main(void)
{
	srand((unsigned)time(NULL));
	int a[10];
	for (int i = 0; i < 10; i++) {
		a[i] = i;
	}
	randomized_in_place(a, sizeof(int), 10);
	printf("排序前:\n");
	print_array(a, 10);
	randomize_quick_sort(a, sizeof(int), 0, 9, cmp_int);
	printf("排序后:\n");
	print_array(a, 10);
	return 0;
}