排序 on ZRJ | 学习笔记

生成可重集的排列

Fri, 14 Sep 2012 16:41:26 +0800

刘汝佳在算法竞赛入门经典，http://book.douban.com/subject/4138920/，的 118 页提到生成一个可重集的全排列问题，跟上次的生成一个字符串的全排列很相像，但是写法却巧妙很多

#include <stdio.h>

void quick_sort(int a[], int left, int right)
{
	int i=left, j=right;
	int povit = a[(i+j)/2];
	while (i <= j)
	{
		while (a[i] < povit)
		{
			i++;
		}
		while (a[j] > povit)
		{
			j--;
		}
		if (i <= j)
		{
			int tmp = a[j];
			a[j] = a[i];
			a[i] = tmp;
			i++;
			j--;
		}
	}
	if (left < j)
	{
		quick_sort(a, left, j);
	}
	if (i < right)
	{
		quick_sort(a, i, right);
	}
}

void print_permutation(int n, int *p, int *a, int cur)
{
	int i, j;
	if (cur == n)
	{
		for (i=0; i<n; i++)
		{
			printf("%d ", a[i]);
		}
		printf("n");
	}
	else
	{
		for (i=0; i<n; i++)
		{
			if (!i || p[i]!=p[i-1])
			{
				int c1=0, c2=0;
				for (j=0; j<cur; j++)
				{
					if (a[j] == p[i])
					{
						c1++;
					}
				}
				for (j=0; j<n; j++)
				{
					if (p[i] == p[j])
					{
						c2++;
					}
				}
				if (c1 < c2)
				{
					a[cur] = p[i];
					print_permutation(n, p, a, cur+1);
				}
			}
		}
	}
}

int main()
{
	int n;
	while (scanf("%d", &n) != EOF)
	{
		int *p = new int[n];
		for (int i=0; i<n; i++)
		{
			scanf("%d", &p[i]);
		}
		quick_sort(p, 0, n-1);
		int *a = new int[n];
		print_permutation(n, p, a, 0);
		delete[] p;
		delete[] a;
	}
	return 0;
}

输入输出

需要说明的是，他的这种全排列生成需要数组有序，于是顺便就当作复习了一遍快排了

算法复习之归并排序

Fri, 07 Sep 2012 18:03:29 +0800

今天接到电话面试的时候提到了一个归并排序，之前用的比较少，于是完了之后参照 http://blog.csdn.net/morewindows/article/details/6678165 写了一个归并排序

#include <stdio.h>
#include <stdlib.h>

void merge(int n[], int first, int mid, int last, int temp[])
{
	int i=first, j=mid+1, k=0;
	while (i<=mid && j<=last)
	{
		if (n[i] < n[j])
		{
			temp[k++] = n[i++];
		}
		else
		{
			temp[k++] = n[j++];
		}
	}
	while (i <= mid)
	{
		temp[k++] = n[i++];
	}
	while (j <= last)
	{
		temp[k++] = n[j++];
	}
	for (i=0; i<k; i++)
	{
		n[first+i] = temp[i];
	}
}

void m_sort(int n[], int first, int last, int temp[])
{
	if (first < last)
	{
		int mid = (first + last) / 2;
		m_sort(n, first, mid, temp);
		m_sort(n, mid+1, last, temp);
		merge(n, first, mid, last, temp);
	}
}

int main()
{
	int k;
	scanf("%d", &k);
	int *n = (int *)malloc(k*sizeof(int));
	int *temp = (int *)malloc(k*sizeof(int));
	if (!n || !temp)
	{
		exit(1);
	}
	int i;
	for (i=0; i<k; i++)
	{
		scanf("%d", &n[i]);
	}
	m_sort(n, 0, k-1, temp);
	for (i=0; i<k; i++)
	{
		printf("%d ", n[i]);
	}
	printf("n");
	free(n);
	free(temp);
}

输入输出：

5
3 1 2 4 0
0 1 2 3 4

归并排序的时间复杂度是 O(n*log(n))，数据是稳定的

算法复习之快速排序

Fri, 10 Aug 2012 17:27:37 +0800

快速排序这个自己想了一会，真的想不出来，还是查了资料，使用 C89 标准函数库有一个非常简单的写法，（维基上的不能跑，自己稍稍改了一下）

#include <stdio.h>
#include <stdlib.h>

static int cmp(int *a, int *b)
{
	return *a-*b;
}

int main()
{
	int arr[10]={5, 3, 7, 4, 1, 9, 8, 6, 2};

	qsort(arr, 10, sizeof(int), (int(*) (const void *,const void *))cmp);

	return 0;
}

而我交到 hdu 的是

#include <stdio.h>
#define MAX 1005

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void quick_sort(int arr[], int left, int right)
{
	int i = left, j = right;
	int pivot = arr[(i+j)/2];
//	printf("pivot is %dn", pivot);
	while (i <= j)
	{
		while (arr[i] < pivot)
		{
			i++;
		}
		while (arr[j] > pivot)
		{
			j--;
		}
		if (i <= j)
		{
		//	printf("swapping arr[%d]:%d and arr[%d]:%dn",
		//		i, arr[i], j, arr[j]);
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
			i++;
			j--;
		}
	}
	if (left < j)
	{
		quick_sort(arr, left, j);
	}
	if (i < right)
	{
		quick_sort(arr, i, right);
	}
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		int n = get(arr);
		quick_sort(arr, 0, n-1);
		print(arr, n);
	}
	return 0;
}

最后，附上一个 python 的版本，再次体会到 python 的简洁

def qsort(L):
   if not L: return []
   return qsort([x for x in L[1:] if x< L[0]]) + L[0:1] + 
          qsort([x for x in L[1:] if x>=L[0]])

不仅简洁，而且思路非常清晰，易懂，不过 python 这个版本空间复杂度比较高就是了

==============================================================

2012-08-11 00:37:12 update: 上面那个快排，有两个地方想不懂：

在 31 行 while 循环那里，为什么需要小于等于呢，为什么不能去掉等号呢
在 52 和 56 行那里，为什么需要判断 if 呢，那个地方是一个递归终止条件这我知道，问题是，那个 if 在什么情况下会不成立呢，i 从左往右递增，怎么会超过 right 呢，同理 j 也一样啊

==============================================================

2012-08-11 01:01:26 update: 第二个问题看下面这个代码的输出应该就能有体会了，具体我也不知道怎么说

#include <stdio.h>
#define MAX 1005

int total;
int *p_arr;

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	n = total;
	arr = p_arr;
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void quick_sort(int arr[], int left, int right)
{
	int i = left, j = right;
	int pivot = arr[(i+j)/2];
	printf("left is %d right is %d pivot is %dn", left, right, pivot);
	while (i <= j)
	{
		while (arr[i] < pivot)
		{
			i++;
		}
		while (arr[j] > pivot)
		{
			j--;
		}
		if (i <= j)
		{
			printf("swapping arr[%d]:%d and arr[%d]:%dn",
				i, arr[i], j, arr[j]);
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
			i++;
			j--;
			print(arr, 0);
		}
	}
	if (left < j)
	{
		quick_sort(arr, left, j);
	}
	else
	{
		printf("left is %d and not smaller than j is %dn", left, j);
	}
	if (i < right)
	{
		quick_sort(arr, i, right);
	}
	else
	{
		printf("i is %d and not smaller than right is %dn", i, right);
	}
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		p_arr = arr;
		int n = get(arr);
		total = n;
		quick_sort(arr, 0, n-1);
		print(arr, n);
		printf("donen");
	}
	return 0;
}

至于第一个问题嘛，我把等于号删掉了，交到 hdu 上是可以过的，看起来应该是没问题的，但是怎么证明呢

算法复习之冒泡排序与选择排序

Fri, 10 Aug 2012 13:23:29 +0800

基础丢的差不多了，是时候该重新捡起来，不然真的心虚啊，于是就从排序开始，上 poj 找基础的排序题居然没有，悲催，太低级了，最后在 hdu 上找到一个排序题，http://acm.hdu.edu.cn/showproblem.php?pid=1040

忘得差不多也有一个好处，就是可以自己从头再想，这次决定不看任何参考资料，就凭着模糊的印象，慢慢的把算法的思路先理清楚，然后动手写，再手工调，一点点来，这样才能更好的理解，悲催的是，一个冒泡排就搞了一个上午啊

#include <stdio.h>
#define MAX 1005

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void sort(int arr[], int n)
{
	int i, j;
	for (i=0; i<n-1; i++)
	{
	//	printf("processing arr[%d]:%dn", i, arr[i]);
		for (j=0; j<n-i-1; j++)
		{
		//	printf("checking for arr[%d]:%d and arr[%d]:%dn",
		//		j, arr[j], j+1, arr[j+1]);
			if (arr[j] > arr[j+1])
			{
			//	printf("swapping arr[%d]:%d and arr[%d]:%dn",
			//		j, arr[j], j+1, arr[j+1]);
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			//	print(arr, n);
			}
		}
	}
//	printf("donen");
	return;
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		int n = get(arr);
		sort(arr, n);
		print(arr, n);
	}
	return 0;
}

遇到的问题在于，看高亮的第 32 行，如果把 for 循环的初始条件从 j=0 改成 j=i 就 WA 了，这是为什么呢，有兴趣的可以自己想想

冒泡排序出来了，选择也跟着很快就出来了

#include <stdio.h>
#define MAX 1005

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void sort(int arr[], int n)
{
	int i, j;
	for (i=0; i<n-1; i++)
	{
		int min = i;
		for (j=i+1; j<n; j++)
		{
			if (arr[j] < arr[min])
			{
				min = j;
			}
		}
		if (min != i)
		{
			int temp = arr[i];
			arr[i] = arr[min];
			arr[min] = temp;
		}
	}
	return;
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		int n = get(arr);
		sort(arr, n);
		print(arr, n);
	}
	return 0;
}

选择排序是我觉得最自然，最好理解的排序方法，我记得当时大一的时候，刚接触 C ，什么都没学，自己琢磨出来的就是选择，倒是冒泡还费劲理解。。