Wikioi 天梯 明明的随机数（1075）

题目描述 Description

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤100），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。

输入描述 Input Description

有2行，第1行为1个正整数，表示所生成的随机数的N个数：

 

第2行有N个用空格隔开的正整数，为所产生的随机数

 

输出描述 Output Description

第1行为1个正整数M，表示不相同的随机数的个数。第2行为M个用空格隔开的正整数，为从小

到大排好序的不相同的随机数。

样例输入 Sample Input

10

20 40 32 67 40 20 89 300 400 15

样例输出 Sample Output

8

15 20 32 40 67 89 300 400

 

数据范围及提示 Data Size & Hint

 

本题只有100个数，所以目的基本是为了让大家熟悉排序算法。

下面介绍几种pascal常用的排序算法（强烈羡慕嫉妒恨C党的sort）：

1.冒泡排序：算法共n-1次操作，每次扫描整个（其实不必）数列，比较相邻两数以保证两数顺序符合目标序列的增减性。可以证明，第i次操作后，前（后）i个数符合递增（递减）关系。PS：此方法笔者学的也不很透彻，深感讲的模糊~~。由于进行n-1次操作，每次操作进行n-1次比较，所以算法时间复杂度为O(n^2)。

Program bubblesort;
Var
	a:array[0..1000]of longint;
	i,j:integer;
   
Procedure swap(var aa,bb:longint);
	var cc:longint;
	begin
		cc:=aa;
		aa:=bb;
		bb:=cc;
	end;
   
Begin
	fillchar(a,sizeof(a),0);
	readln(a[0]);
	for i:=1 to a[0] do read(a[i]);
	for i:=1 to a[0]-1 do
		for j:=1 to a[0]-i do
			if a[j]>a[j+1] then swap(a[j],a[j+1]);
	for i:=1 to a[0] do write(a[i],' ');   
End.

2.选择排序：这个算法很好理解，我们给n个数排序，该算法进行n次取最大或最小值得操作，每从剩下的部分取一次极值就把它放入新序列。这样，显而易见，第一次取得极值自然是全列第一大的，第i次取得的极值是全列第i大的，按照极值的取出顺序形成的序列自然符合单调性。由于进行了n次选择，每次选择需要扫描未排序序列，所以算法时间复杂度为O(n^2)。

Program choosesort;
Var
	a:array[0..1000]of longint;
	min:longint;
	i,j:longint;

Procedure swap(var aa,bb:longint);
	var cc:longint;
	begin
		cc:=aa;
		aa:=bb;
		bb:=cc;
	end;

Begin
	fillchar(a,sizeof(a),0);
	a[10001]:=maxlongint;
	readln(a[0]);
	for i:=1 to a[0] do read(a[i]);
	for i:=1 to a[0]-1 do
		begin
			min:=10001;
			for j:=a[0] downto i do
				if a[min]>a[j] then min:=j;
			swap(a[i],a[min]);
		end;
	for i:=1 to a[0] do write(a[i],' ');
End.

3.插入排序：将第一个数默认为已排好的一个序列，从第二个数开始，依次将i个数插入序列中的正确位置。由于进行了n-1次插入，以及每次插入时对已排好的序列进行扫描找插入位置（递增序列中此位置i满足a[i-1]<该数<a[i+1]）。算法时间复杂度O(n^2)。

Program insertsort;
Var
	a:array[0..1000]of integer;
	i,j,r:integer;

Procedure swap(var aa,bb:integer);
	var cc:integer;
	begin
		cc:=aa;
		aa:=bb;
		bb:=cc;
	end;

Begin
	fillchar(a,sizeof(a),0);
	readln(a[0]);
	for i:=1 to a[0] do read(a[i]);
	for i:=2 to a[0] do
		begin
			j:=i;
			r:=a[i];
			while a[j-1]>r do
				begin
					a[j]:=a[j-1];
					dec(j);
				end;
			a[j]:=r;
		end;
	for i:=1 to a[0] do write(a[i],' ');
End.

4.快速排序：最坏log(n)层递归，每次递归随机在序列中取一个数（我们称它为标志数），对序列进行操作，实现该数不变，该数前面的数比它小，后面的数比它大。具体实现是双指针，左指针从序列首向序列尾移动，直到所指的数大于标志数；右指针从序列尾向序列首移动，直到所指的数小于标志数，这时交换两指针所指数。不断进行此操作直到左指针大于右指针。由于每次递归进行一次双向扫描O(n)，最坏log(n)层递归，所以最坏复杂度为O(nlog(n))。

Program quicksort;
Var
	a:array[1..100000]of longint;
	i,k:longint;

Procedure swap(var aa,bb:longint);
	var cc:longint;
	begin
		cc:=aa;
		aa:=bb;
		bb:=cc;
	end;
   
Procedure qsort(l,r:longint);
	var mid,ll,rr:longint;
	begin
		ll:=l;
		rr:=r;
		mid:=a[random(rr-ll+1)+ll];	 
		repeat
			while a[ll]<mid do inc(ll);
			while a[rr]>mid do dec(rr);
			if ll<=rr then
				begin
					swap(a[ll],a[rr]);
					inc(ll);
					dec(rr);
				end;
			until ll>rr;
			if ll<r then qsort(ll,r);
			if l<rr then qsort(l,rr);
	end;

Begin
	readln(k);
	randomize;
	for i:=1 to k do
		begin
			read(a[i]);
		end;
	qsort(1,k);
	for i:=1 to k do write(a[i],' ');
End.

5.计数排序：本方法适用于数据本身的值比较小的情况。适用范围内，计数排序复杂度为线性（关于n的一次表达式）。开一个数组，a[i]记录数i的出现次数。说白了就是一个统计表。读入完成后，在数据范围内检查每个数是否出现或出现几次，统计到几个该数就输出几个该数就行了。由于检查顺序保证单调，所以保证输出的是单调数列。

由于对数据范围内每个数都进行操作，操作次数为常数，所以算法时间复杂度为O(maxn)；

Program countsort;
Var
	a:array[1..32767]of integer;
	n:longint;
	i:longint;
	j:integer;
   
Begin
	readln(n);
	fillchar(a,sizeof(a),0);
	for i:=1 to n do
		begin
			read(j);
			inc(a[j]);
		end;
	for i:=1 to 32767 do
		while a[i]<>0 do
			begin
				write(i,' ');
				dec(a[i]);
			end; 
End.

………………敲得手都疼了，不过常用的确实就这几个……什么归并排序、基数排序……了解就行……

算法描述：（打了这么多，还用说吗…）读入数据，排序，输出前进行去重（其实去重用计数原理是很爽的），输出答案。

Program mingming;
Var
	n,a,i,total:longint;
	f:array[1..1000]of boolean;

Begin
	readln(n);
	fillchar(f,sizeof(f),0);
	total:=0;
	for i:=1 to n do
		begin
			read(a);
			if f[a]=false then
				begin
					inc(total);
					f[a]:=true;
				end;
		end;
	writeln(total);
	for i:=1 to 1000 do
		if f[i] then write(i,' ');
End.