Project 3 Hashing

Given a hash table of size N, we can define a hash function H(x) = x%N. Suppose that the linear probing is used to solve collisions, we can easily obtain the status of the hash table with a given sequence of input numbers.

However, now you are asked to solve the reversed problem: reconstruct the input sequence from the given status of the hash table. Whenever there are multiple choices, the smallest number is always taken.

Input Specification:

Each input file contains one test case. For each test case, the first line contains a positive integer N (<=1000), which is the size of the hash table. The next line contains N integers, separated by a space. A negative integer represents an empty cell in the hash table. It is guaranteed that all the non-negative integers are distinct in the table.

Output Specification:

For each test case, print a line that contains the input sequence, with the numbers separated by a space. Notice that there must be no extra space at the end of each line.

Sample Input:

11
33 1 13 12 34 38 27 22 32 -1 21

Sample Output:

1 13 12 21 33 34 38 27 22 32

基本思想

先将数据从小到大排列，然后依顺序对于每一个元素探测，如果被占用的元素大于该元素，则把他放到前面

例如

1 12 13 21 22 27 32 33 34 38

1 13 12 21 22 27 32 33 34 38

1 13 12 21 33 34 38 27 22 32

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

int a[1000],c[1000],cp = 0,bp = 0,visit[1000];

void hashsort(int b[],int position,int n,int num,int flag){
	if(position == n -1)
		return;
	int i,j,tmp;
	i = b[position]%num;
	bp = position;
	while(b[bp] != a[i]){
		if(a[i]>b[bp]){
			for(j = position+1;j<n;j++)
				if(b[j] == a[i])
					break;
				if(j==n) {
					i++;
					continue;
				}
				tmp = b[j];
				while(j!=bp){
					b[j] = b[j-1];
					j--;
				}
				b[bp] = tmp;
				hashsort(b,bp,n,num,0);
				bp++;
			//c[cp++] = b[j];
		}
		i++;
		if(i == n)
			i = 0;
	}
//	c[cp++] = b[position];
	if(flag)
		hashsort(b,bp+1,n,num,1);
}
void swamp(int *a,int *b){
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}
int median3(int a[],int begin,int end){
	int mid;
	mid = (begin + end)/2;
	if(a[begin]>a[mid])
		swamp(&a[begin],&a[mid]);
	if(a[begin]>a[end])
		swamp(&a[begin],&a[end]);
	if(a[mid]>a[end])
		swamp(&a[mid],&a[end]);
	swamp(&a[mid],&a[end-1]);
	return a[end-1];
}
void Insertsort(int a[],int n){
	int i,j,tmp;
	for(i = 1;i<n;i++){
		tmp = a[i];
		for(j = i;a[i]<a[j-1]&&j>0;j--)
			a[j] = a[j-1];
		a[j] = tmp;
	}
}
void partition(int a[],int begin,int end){
	int i,j;
	int pivot;
	if(end - begin>4){
		pivot = median3(a,begin,end);
		i = 0;
		j = end-1;
		while(1){
			while(a[++i]<pivot);
			while(a[--j]>pivot);
			if(i<j)
				swamp(&a[i],&a[j]);
			else break;
		}
		swamp(&a[i],&a[end-1]);
		partition(a,begin,i-1);
		partition(a,i+1,end);
	}
	else Insertsort(a + begin,end - begin + 1);  //the array start from a + begin 
}
void quicksort(int a[],int n){
	partition(a,0,n-1);
}
int main(){
	int n,i,valid,bp;
	int *b;
	FILE *fp;
	//fp = fopen("test.txt","r");
	fscanf(stdin,"%d",&n);
	b = (int *)malloc(sizeof(int)*n);
	for(i = 0,valid = 0,bp = 0;i<n;i++){
		fscanf(stdin,"%d",&a[i]);
		if(a[i]<0)
			valid++;
		else b[bp++] = a[i];
	}
	quicksort(b,n-valid);
	hashsort(b,0,n-valid,n,1);
	for(i = 0;i<n-valid;i++){
		printf("%d",b[i]);
		if(i == n - valid - 1)
			printf("\n");
		else printf(" ");
	}
	free(b);
	return 0;
}