算法导论代码 第5章 概率分析和随机算法

5章 概率分析和随机算法

5.1 雇用问题

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
void hire_assistant(int A[], int n)
{
	int best = 0;
	printf("hire:");
	for (int i = 0; i < n; i++) {
		if (A[i] > best) {
			best = A[i];
			printf("%d ", i);
		}
	}
	printf("\n");
}

int main()
{
	srand((unsigned)time(NULL));
	int a[10];
	for (int i = 0; i < 10; i++) {
		a[i] = rand() % 100;
		printf("%d ", a[i]);
	}
	printf("\n");
	hire_assistant(a, 10);
	return 0;
}

5.3 随机算法

5.3.1 通过排序产生随机排列数组

#include <stdio.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
void merge(void *base, size_t elem_size, size_t left, size_t middle,
	   size_t right, void *max, int (*comp) (const void *, const void *),
	   void *buff)
{
	char *cbase = base;
	char *cbuff = buff;
	size_t left_length = middle - left + 1;
	size_t right_length = right - middle;
	char *left_buff = cbuff;
	char *right_buff = &cbuff[(left_length + 1) * elem_size];
	for (size_t i = 0; i < left_length; i++) {
		memcpy(&left_buff[i * elem_size],
		       &cbase[(left + i) * elem_size], elem_size);
	}
	memcpy(&left_buff[left_length * elem_size], max, elem_size);
	for (size_t i = 0; i < right_length; i++) {
		memcpy(&right_buff[i * elem_size],
		       &cbase[(middle + 1 + i) * elem_size], elem_size);
	}
	memcpy(&right_buff[right_length * elem_size], max, elem_size);
	for (size_t k = left, i = 0, j = 0; k <= right; k++) {
		if (comp(&left_buff[i * elem_size], &right_buff[j * elem_size])
		    <= 0) {
			memcpy(&cbase[k * elem_size], &left_buff[i * elem_size],
			       elem_size);
			i++;
		} else {
			memcpy(&cbase[k * elem_size],
			       &right_buff[j * elem_size], elem_size);
			j++;
		}
	}
}

void merge_sort_buff(void *base, size_t elem_size, size_t left, size_t right,
		     void *max, int (*comp) (const void *, const void *),
		     void *buff)
{
	if (left < right) {
		size_t middle = (left + right) / 2;
		merge_sort_buff(base, elem_size, left, middle, max, comp, buff);
		merge_sort_buff(base, elem_size, middle + 1, right, max, comp,
				buff);
		merge(base, elem_size, left, middle, right, max, comp, buff);
	}
}

void merge_sort(void *base, size_t elem_size, size_t left, size_t right,
		void *max, int (*comp) (const void *, const void *))
{
	if (left >= right)
		return;
	size_t length = right - left + 1;	/*数组的长度 */
	char buff[(length + 2) * elem_size];	/*+2是因为要在缓存保存两个最大值 */
	merge_sort_buff(base, elem_size, left, right, max, comp, buff);
}

struct rand_data {
	int rand_num;
	void *data;		/*挷定了一个数据的指针 */
};
int cmp_data(const void *p1, const void *p2)
{
	const struct rand_data *pa = p1;
	const struct rand_data *pb = p2;
	return pa->rand_num - pb->rand_num;
}

void permute_by_sorting(void *base, size_t elem_size, int length)
{
	char *cbase = base;
	/*把原来的数组复制一份 */
	char data_copy[elem_size * length];
	memcpy(data_copy, base, elem_size * length);
	struct rand_data rand_data_array[length];
	for (int i = 0; i < length; i++) {
		rand_data_array[i].rand_num =
		    rand() % (length * length * length);
		rand_data_array[i].data = &data_copy[i * elem_size];
	}
	struct rand_data data_max = { INT_MAX, NULL };
	merge_sort(rand_data_array, sizeof(struct rand_data), 0, length - 1,
		   &data_max, cmp_data);
	/*根据按随机数排序的结果把数据复制回原来的数组 */
	for (int i = 0; i < length; i++) {
		memcpy(&cbase[i * elem_size], rand_data_array[i].data,
		       elem_size);
	}
}

void randomized_hire_assistant(int A[], int length)
{
	permute_by_sorting(A, sizeof(int), length);
	printf("hire:");
	int best = 0;
	for (int i = 0; i < length; i++) {
		if (A[i] > best) {
			best = A[i];
			printf("%d ", i);
		}
	}
	printf("\n");
}

int main()
{
	srand((unsigned)time(NULL));
	int a[10];
	for (int i = 0; i < 10; i++) {
		a[i] = i;
	}
	randomized_hire_assistant(a, 10);
	return 0;
}


5.3.2 通过原地排列产生随机排列数组

#include <stdio.h>
#include <stdlib.h>
#include <time.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);
}
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 randomized_hire_assistant(int A[], int n)
{
	randomized_in_place(A, sizeof(int), n);
	int best = 0;
	printf("hire:");
	for (int i = 0; i < n; i++) {
		if (A[i] > best) {
			best = A[i];
			printf("%d ", i);
		}
	}
	printf("\n");
}

int main()
{
	srand((unsigned)time(NULL));
	int a[10];
	for (int i = 0; i < 10; i++) {
		a[i] = i;
	}
	randomized_hire_assistant(a, 10);
	return 0;
}


5.4.4 在线雇用问题

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <string.h>
#include <limits.h>
int on_line_maximum(int A[], int n, int k)
{
	int best_score = -INT_MAX;
	for (int i = 0; i < k; i++) {
		if (A[i] > best_score) {
			best_score = A[i];
		}
	}
	for (int i = k; i < n; i++) {
		if (A[i] > best_score) {
			return i;
		}
	}
	return n - 1;
}

int main()
{
	srand((unsigned)time(NULL));
	int a[10];
	for (int i = 0; i < 10; i++) {
		a[i] = rand() % 100;
	}
	int n = on_line_maximum(a, 10, 10 / exp(1.0));
	/*测试n是不是最好的*/
	bool flag = true;
	for (int i = 0; i < 10; i++) {
		if (a[i] > a[n]) {
			flag = false;
		}
	}
	printf("%s\n",flag?"true":"false");
	return 0;
}


你可能感兴趣的:(算法导论代码 第5章 概率分析和随机算法)