How to sort an array in SAS?5 min read

While working on arrays in SAS, we may need to sort the array in ascending or descending order. In this post, I will demonstrate different methods and techniques you can use to sort an array in SAS.

Call SORTN Routine

The CALL SORTN Routine sorts the values of numeric arguments in an array. I have created a numeric array x with ten elements. Then, to sort the array in ascending order I have to use the Call SortN Routine with the Of keyword and specify x[*] as the argument.

The SORTN call routine will sort the values of the variables in ascending order and replace the Program Data Vector
values with the new sorted values

data _null_;
   array x {10} (80 1 32 5 44 55 19 92 33 66);
   put 'Before Sort';
   put +3 (x[*])(=);
   call sortn (of x[*]);
   put 'After Sort';
   put +3 (x[*])(=);
run;

Output

CALL SORTC Routine

The CALL SORTC Routine sorts the values of character arguments in an array. See the example below where I have created a character array and used CALL SORTC to sort the array.

data _null_;
	array x(8) $10
      ('Apricots' 'Fig' 'Blueberries' 'Gooseberries' 'Olive' 'Watermelon' 
		'banana' 'Jackfruit');
	put 'Before Sort';
	put +3 (x[*])(=);
	call sortc(of x(*));
	put 'After Sort';
	put +3 (x[*])(=);
run;

Sorting in descending order

The Call routines SORTN and SORTC can be used to sort arrays in ascending order only. What if you want to order it in descending order?

Here is an easy way to achieve this.

data _null_;
   array x {10} (80 1 32 5 44 55 19 92 33 66);
   put 'Before Sort';
   array y[*] x10-x1;
   put +3 (x[*])(=);
   call sortn (of y[*]);
   put 'After Sort';
   put +3 (x[*])(=);
run;

Bubble Sort Algorithm

The bubble sort is one of the simplest sorting algorithms. Bubble sort works its way through the array comparing each value to its adjacent value and swapping them if they are not in the correct order.

The bubble sort will pass through the list until no swapping is needed and the list is in proper order.

Starting with an unsorted list of array  [9,1,65] the bubble sort will first compare 9 to 1, determine that 9 > 1, bubble sort will swap the position resulting [1,9,6,5] and move on to the next comparison. Now, the second comparison is 1 to 9 Since 1 < 9 no swapping is done.

The algorithm continues until it reaches the last element in the array, then it starts over at the beginning (Pass 2). It will continue like this until there are no more swaps done.

data _null_;
	array x {4} (9 1 6 5);
	put 'Before Sort';
	put +3 (x[*])(=);
	n=dim(x);
	j=1;
	do until (stop);
		stop=1;
		put 'PASS = ' j;
		do i=1 to n-1;
			if x(i) > x(i+1) then
				do;
					put i +3 x[*] +5 'Comparing ' x(i) 'and ' x(i+1) +3 x(i) '> ' x(i+1) 
						'= T ' 'Swapping ' x(i) ' and ' x(i+1);
					temp=x(i+1);
					x(i+1)=x(i);
					x(i)=temp;
					stop=0;
				end;
			put i +3 x[*] +5 'Comparing ' x(i) 'and ' x(i+1) +3 x(i) '> ' x(i+1) '= F ' 
				'No Swapping done';
		end;
		j=j+1;
	end;
	put 'After Sort';
	put +3 (x[*])(=);
run;

Before Sort
x1=9 x2=1 x3=6 x4=5
PASS = 1
9 1 6 5 Comparing 9 and 1 9 > 1 = T Swapping 9 and 1
1 9 6 5 Comparing 1 and 9 1 > 9 = F No Swapping done
1 9 6 5 Comparing 9 and 6 9 > 6 = T Swapping 9 and 6
1 6 9 5 Comparing 6 and 9 6 > 9 = F No Swapping done
1 6 9 5 Comparing 9 and 5 9 > 5 = T Swapping 9 and 5
1 6 5 9 Comparing 5 and 9 5 > 9 = F No Swapping done
PASS = 2
1 6 5 9 Comparing 1 and 6 1 > 6 = F No Swapping done
1 6 5 9 Comparing 6 and 5 6 > 5 = T Swapping 6 and 5
1 5 6 9 Comparing 5 and 6 5 > 6 = F No Swapping done
1 5 6 9 Comparing 6 and 9 6 > 9 = F No Swapping done
PASS = 3
1 5 6 9 Comparing 1 and 5 1 > 5 = F No Swapping done
1 5 6 9 Comparing 5 and 6 5 > 6 = F No Swapping done
1 5 6 9 Comparing 6 and 9 6 > 9 = F No Swapping done
After Sort
x1=1 x2=5 x3=6 x4=9

The bubble sort works really well on small data sets where processing time will be negligible. For large data sets more efficient
alternatives are available, such as the quicksort algorithm.

The quicksort algorithm is also known as the ‘divide and conquer algorithm’. The first step is to divide the list of data values into two sets of lists and then sorting the smaller lists by splitting them up further into even smaller lists.

The algorithm isn’t as easy to implement as the bubble sort but it is considered to be more efficient – when sorting large datasets. The quicksort algorithm is implemented in the article Quicksorting An Array by Paul Dorfman.

We Recommend: