void RadixMap_sort(RadixMap *map) {
uint64_t *source = &map->contents[0].raw;
uint64_t *temp = &map->temp[0].raw;
radix_sort(0, map->end, source, temp);
radix_sort(1, map->end, temp, source);
radix_sort(2, map->end, source, temp);
radix_sort(3, map->end, temp, source);
}
main()
{
struct node *tmp,*q;
int i,n,item;
printf("Enter the number of elements in the list : ");
scanf("%d", &n);
for(i=0;i<n;i++)
{
printf("Enter element %d : ",i+1);
scanf("%d",&item);
/* Inserting elements in the linked list */
tmp= malloc(sizeof(struct node));
tmp->info=item;
tmp->link=NULL;
if(start==NULL) /* Inserting first element */
start=tmp;
else
{
q=start;
while(q->link!=NULL)
q=q->link;
q->link=tmp;
}
}/*End of for*/
printf("Unsorted list is :\n");
display();
radix_sort();
printf("Sorted list is :\n");
display ();
}/*End of main()*/
int main(int argc, char *argv[])
{
int i;
int array[30] = { 258, 976, 515, 337, 359, 701, 916, 494, 303, 175,
677, 825, 131, 560, 147, 254, 759, 814, 917, 382,
452, 114, 873, 585, 881, 127, 819, 658, 461, 435
};
int len = 30; /* 测试数据个数 */
int dec = 3; /* 数据位数，3代表3位数 */
int order = 1; /* 排序的位数，1代表个位、2代表十位、3代表百位 */
printf("before\n");
for (i = 0; i < 30; i++)
printf("%d ", array[i]);
printf("\n");
/* 排序函数，从个位开始 */
radix_sort(array, len, dec, order);
printf("final\n");
for (i = 0; i < 30; i++)
printf("%d ", array[i]);
printf("\n");
return 0;
}
int main()
{
int n,big_n;
printf("How many elements? ");
scanf("%d",&n);
printf("Largest element? ");
scanf("%d",&big_n);
int a[n];
int i;
for(i=0;i<n;i++)
a[i]=rand()%big_n;
print_array(a,n);
printf("\n");
radix_sort(a,n,big_n-1);
print_array(a,n);
}
int main(int argc,char *argv[]){
FILE *fp;
int i=0;
if((fp=fopen(argv[1],"r"))==NULL){
printf("can't open the file!");
exit(0);
}
while(fscanf(fp,"%d",&data[i])!=EOF)
i++;
n = i;
get_max_num();
int rank;
MPI_Init(&argc, &argv);
// get the id of process
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
radix_sort(rank);
if(rank == 0){
printf("the smallest number is: %d\n",data[0]);
printf("the n/4 smallest number is: %d\n",data[n/4]);
printf("the n/2 smallest number is: %d\n",data[n/2]);
printf("the largest number is: %d\n",data[n - 1]);
}
MPI_Finalize();
return 0;
}
int main(int argc, char ** argv)
{
// Открываем файлы и считываем данные
FILE *fin, *fout;
fin = fopen("numbers.txt", "r");
fout = fopen("output.txt", "w");
if(fin == NULL || fout == NULL)
{
printf("Error!");
return 1;
}
int n, i;
fscanf(fin, "%d", &n);
int * A = (int *)malloc(n * sizeof(int));
for ( i = 0; i < n; ++i )
{
fscanf(fin, "%d", &A[i]);
}
fclose(fin);
// Сортируем
radix_sort(A, n);
// Записывае данные и закрываем файлы
for (int i = 0; i < n; ++i)
fprintf(fout, "%d ", A[i]);
fclose(fout);
free(A);
return 0;
}
int main(int argc, char *argv[]){
if(argc != 2){
fprintf(stderr, "Correct Usage: %s <VECTOR_LENGTH>\n", argv[0]);
exit(-1);
}
int *vec, length;
clock_t init, end;
length = atoi(argv[1]);
vec = create_vector(length);
//print_vector(vec, length);
init = clock();
vec = radix_sort(vec, length);
end = clock();
//print_vector(vec, length);
printf("%f\n", (float) (end-init) / (float) CLOCKS_PER_SEC);
return 0;
}
void main()
{
int array[100],n,i;
clrscr();
printf("Enter the number of elements to be sorted: ");
scanf("%d",&n);
printf("\nEnter the elements to be sorted: \n");
for(i = 0 ; i < n ; i++ )
{
scanf("%d",&array[i]);
}
printf("\nBefore Radix Sort:");
for(i = 0; i < n; i++)
{
printf("%d\t", array[i]);
}
printf("\n");
radix_sort(array,n);
printf("\nArray After Radix Sort: "); //Array After Radix Sort
for(i = 0; i < n; i++)
{
printf("%d\t", array[i]);
}
printf("\n");
getch();
}
void main()
{
int op;
clrscr();
do
{
printf("\n1:Insertion Sort\t2:Radix Sort\t3:Shell Sort\t4:Display\t5:Exit\n");
printf("Enter the option");
scanf("%d",&op);
switch(op)
{
case 1:insertion_sort();
break;
case 2:radix_sort();
break;
case 3:shell_sort();
break;
case 4:display();break;
case 5:exit();
break;
}
}
while(op);
getch();
}
int main() {
u_i len = 12;
int arr[12] = {2, 13, 12, 16, 15, 4, 17, 8, 1, 18, 14, 9};
int *temp1 = copy(arr, len);
insertion_sort(temp1, len);
int *temp2 = copy(arr, len);
quick_sort(temp2, len);
int *temp3 = copy(arr, len);
merge_sort(temp3, len);
int *temp4 = copy(arr, len);
selection_sort(temp4, len);
int *temp5 = copy(arr, len);
counting_sort(temp5, len);
int *temp6 = copy(arr, len);
heap_sort(temp6, len);
int *temp7 = copy(arr, len);
radix_sort(temp7, len);
bool eq = equal(temp1, temp2, len) &
equal(temp2, temp3, len) &
equal(temp3, temp4, len) &
equal(temp4, temp5, len) &
equal(temp5, temp6, len) &
equal(temp6, temp7, len);
printf("\x1B[32m""Equal arrays :%s\n""\033[0m", eq ? "true" : "false");
// Free all arrays allocated.
}
static void RadixMap_sort_optimized(RadixMap *map, uint64_t max, size_t starting_index,
uint32_t smallest_key, uint32_t biggest_key)
{
uint64_t *source = &map->contents[starting_index].raw;
uint64_t *temp = &map->temp[starting_index].raw;
uint32_t range_key = smallest_key | biggest_key;
int i = 0;
int drop_high_digits = 0;
int drop_low_digits = 0;
for(i = DIGITS - 1; i >= 0; i--) {
if(ByteOf(&range_key, i) == 0) {
drop_high_digits++;
} else {
break;
}
}
for(i = 0; i < DIGITS; i++) {
if(ByteOf(&range_key, i) == 0) {
drop_low_digits++;
} else {
break;
}
}
int significant_digits = 0;
for(i = drop_low_digits; i < DIGITS - drop_high_digits; i++) {
if(significant_digits % 2 == 0) {
radix_sort(i, max, source, temp);
} else {
radix_sort(i, max, temp, source);
}
significant_digits++;
}
if(significant_digits > 0 && significant_digits % 2 == 1) {
memcpy(source, temp, max * sizeof(uint64_t));
}
}
int main() {
int list[] = {435,1432,6456,23432,732,234,6546,234,76571,123};
print_list(list, 10);
radix_sort(list, 10);
print_list(list, 10);
return 0;
}
void test() {
int len = 16, x[16], i;
each(i, len) x[i] = rand() % 512 - 256;
each(i, len) printf("%d%c", x[i], i + 1 < len ? ' ' : '\n');
radix_sort(x, len);
each(i, len) printf("%d%c", x[i], i + 1 < len ? ' ' : '\n');
}
int main(int argc, char **args)
{
int array[SIZE] =
{ 305, 403, 417, 922, 429, 78, 7, 20, 446, 23 };
display(array, SIZE);
radix_sort(array, SIZE);
return 0;
}
void sort_numbers(item *A, int size, int max_digits) {
int groups[max_digits + 1];
partition(A, size, max_digits, groups, item_digits);
for (int i = 1; i < max_digits + 1; i++) {
radix_sort(A, groups[i - 1], groups[i], i, item_nth_digit);
}
}
int main(){
/*
*/
int data[]={64,8,216,512,27,729,0,1,343,125,93};
int size=sizeof(data)/sizeof(int);
radix_sort(data,size,3);
displayoutcome(data,size);
return 0;
}
int solution(int A[], int N) {
radix_sort(A, A + N, 1 << 30);
for (int i = 0; i < N - 1; i+=2) {
if (A[i] != A[i + 1]) {
return A[i];
}
}
return A[N - 1];
}
// test for big number of elements
static void test_radix (ulong N)
{
rec *data = (rec *) malloc (N * sizeof (rec));
assert (data != NULL);
make_random (data, N);
radix_sort (data, N);
check_order (data, N);
free (data);
}
void all_radix_sort(int n){
int i;
int t = 1;
int m = 0;
// データ内の最大桁数(7桁)分を繰り返しソートしていく
for(i = 0; i <= 7; i++){
radix_sort(n, t); // n個のデータ,t桁目
t++;
}
}
int main(void)
{
int len = 16, x[16], i;
size_t len = 16, i;
each(i, len) x[i] = rand() % 512 - 256;
radix_sort(x, len);
each(i, len) printf("%d%c", x[i], i + 1 < len ? ' ' : '\n');
return 0;
}
int main() {
/* integers all must have the same amount of digits */
int seq[SEQUENCE_LENGTH] = {7325, 1334, 4432, 5991, 1324, 8421, 5838, 3492, 6539, 3591};
print_before_message();
print_sequence(seq);
radix_sort(seq);
print_after_message();
print_sequence(seq);
}
static void RadixMap_sort_with_key(RadixMap *map, UINT32_T key)
{
uint64_t *source = &map->contents[0].raw;
uint64_t *temp = &map->temp[0].raw;
if (key.byte._3) {
radix_sort(3, map->end, temp, source);
} else if (key.byte._2) {
radix_sort(2, map->end, source, temp);
radix_sort(3, map->end, temp, source);
} else if (key.byte._1) {
radix_sort(1, map->end, temp, source);
radix_sort(2, map->end, source, temp);
radix_sort(3, map->end, temp, source);
} else {
radix_sort(0, map->end, source, temp);
radix_sort(1, map->end, temp, source);
radix_sort(2, map->end, source, temp);
radix_sort(3, map->end, temp, source);
}
}
int main(int argc, char**argv)
{
int i;
int arr[] = {4, 5, 2, 6, 2, 3, 1, 1};
int arr1[] = {23, 51, 232, 61324, 1161, 22};
radix_sort(arr, 8, 1);
for (i = 0; i < 8; ++i) {
printf("%d ", arr[i]);
}
printf("\n");
radix_sort(arr1, 6, 5);
for (i = 0; i < 6; ++i) {
printf("%d ", arr1[i]);
}
printf("\n");
return 0;
}
/* sort signed ints > 0 */
static void radix_sort(int *from, int *to, int bit)
{
if (!bit || to < from + 1) return;
int *ll = from, *rr = to - 1, tmp;
while (1) {
/* find left most with bit, and right most without bit, swap */
while (ll < rr && !(*ll & bit)) ll++;
while (ll < rr && (*rr & bit)) rr--;
if (ll >= rr) break;
int temp = *ll;
*ll = *rr;
*rr = temp;
}
if (!(bit & *ll) && ll < to) ll++;
bit >>= 1;
radix_sort(from, ll, bit);
radix_sort(ll, to, bit);
}
int main()
{
// Input array
int arr[] = {3, 56, 34, 21, 595, 606, 65, 809, 93, 12};
int arr_size = sizeof(arr)/sizeof(int);
printf("Array before sorting\n");
print(arr, arr_size);
printf("Array Size is %d\n", arr_size);
// Radix sort function call
radix_sort(arr, arr_size);
printf("Array after radix sorting\n");
printf("Array size id %d\n", arr_size);
print(arr, arr_size);
}
int main(int argc, char** argv)
{
int print_results = 0;
// check for correct number of arguments
if (argc < 3) {
usage();
return EXIT_FAILURE;
} else if (argc > 3) {
print_results = atoi(argv[3]);
}
// initialize vars and allocate memory
const int n = atoi(argv[2]);
int* a = malloc(sizeof(int) * n);
// initialize local array
if (init_array(argv[1], 0, n, &a[0]) != EXIT_SUCCESS) {
printf("File %s could not be opened!\n", argv[1]);
return EXIT_FAILURE;
}
// take a timestamp before the sort starts
timestamp_type time1, time2;
get_timestamp(&time1);
// sort elements
radix_sort(&a[0], n);
// take a timestamp after the process finished sorting
get_timestamp(&time2);
// calculate fish updates per second
double elapsed = timestamp_diff_in_seconds(time1,time2);
printf("%f s\n", elapsed);
printf("%d elements sorted\n", n);
printf("%f elements/s\n", n / elapsed);
// print sorted resutls
if (print_results) {
print_array(&a[0], n);
}
// release resources no longer used
free(a);
return 0;
}
void input(void)
{
void output(int a[],int n);
void radix_sort(int a[],int n);
printf("How many elements in the array : ");
scanf("%d",&n);
printf("\n");
printf("Enter the elements : \n");
for(i=0;i<=n-1;i++)
{
scanf("%d",&a[i]);
}
radix_sort(a,n);
printf("Sorted Array : \n");
output(a,n);
}
int maximumGap_sort(std::vector<int>& nums)
{
auto sz = nums.size();
if(sz<2)
{
return 0;
}
radix_sort(nums);
int max_gap = 0;
for(size_t i=1; i<nums.size(); ++i)
{
max_gap = std::max(max_gap, nums[i]-nums[i-1]);
}
return max_gap;
}
int main()
{
FILE *f = fopen("outtiny.txt", "w");
if(f == NULL)
{
printf("Could not initialize file\n");
return -1;
}
fprintf(f, "\t1 core\t4 core\n");
for(int N = 1; N < 10000; N += 1)
{
if(N % 10000 == 0) printf ("%d\n", N);
struct timespec start, end;
int* array = generate_rand_array(N);
if(array == NULL)
{
printf("Not enough memory\n");
return -1;
}
clock_gettime(CLOCK_MONOTONIC, &start);
radix_sort(array, N);
clock_gettime(CLOCK_MONOTONIC, &end);
fprintf(f, "%d\t", N);
fprintf(f, "%lf\t",
(double)(diff(start, end).tv_nsec) / 1000000000.0);
clock_gettime(CLOCK_MONOTONIC, &start);
radix_sort_parallel(array, N);
clock_gettime(CLOCK_MONOTONIC, &end);
fprintf(f, "%lf\n",
(double)(diff(start, end).tv_nsec) / 1000000000.0);
free(array);
}
fclose(f);
return 0;
}
void main()
{
int i;
int a[] = {53, 3, 542, 748, 14, 214, 154, 63, 616};
int ilen = LENGTH(a);
printf("before sort:");
for (i=0; i<ilen; i++)
printf("%d ", a[i]);
printf("\n");
radix_sort(a, ilen);
printf("after sort:");
for (i=0; i<ilen; i++)
printf("%d ", a[i]);
printf("\n");
}
