C++ Sort number using bitshifting operations - c++

Question

I wanted to ask how it is possible to sort an integers digit by size using bitshifting operations.
Here is an example:
Input : 12823745
Output : 87543221
Basically sorting the digits from the high digits to the small digits
I heared it is possible without using the Bubblesort/Quicksort algorithms, but by using some bitshifting operations.
Does someone know how that can be achieved?

Answer 1

Quick sort and bubble sort are general purpose algorithms. As such the do not make any assumption on the data to be sorted. However, whenever we have additional information on the data we can use this to get something different (I do not say better/faster or anything like this because it is really hard to be better than something as simple and powerful as quick/bubble sort and it really depends on the specific situation what you need).
If there is only a limited number of elements to be sorted (only 10 different digits) one could use something like this:
#include <iostream>
#include <vector>
using namespace std;
typedef std::vector<int> ivec;
void sort(std::vector<int>& vec){
ivec count(10,0);
for (int i=0;i<vec.size();++i){count[vec[i]]++;}
ivec out;
for (int i=9;i>-1;--i){
for (int j=0;j<count[i];j++){
out.push_back(i);
}
}
vec = out;
}
void print(const ivec& vec){
for (int i=0;i<vec.size();++i){std::cout << vec[i];}
std::cout << std::endl;
}
int main() {
ivec vec {1,2,8,2,3,7,4,5};
sort1(vec);
print(vec);
return 0;
}
Note that this has complexity O(N). Further, this always works when set of possible elements has a finite size (not only for digits but not for floats). Unfortunately it is only practical for really small sizes.
Sometimes it is not sufficient to just count the elements. They might have some identity beside the value that has to be sorted. However, the above can be modified easily to work also in this case (needs quite some copies but still O(n)).
Actually I have no idea how your problem could be solved by using bitshift operations. However, I just wanted to point out that there is always a way not to use a general purpose algorithm when your data has nice properties (and sometimes it can be even more efficient).

Answer 2

Here is a solution - Implement bubble sort with loops and bitwise operations.
std::string unsorted = "37980965";
for(int i = 1; i < unsorted.size(); ++i)
for(int j = 0; j < i; ++j) {
auto &a = unsorted[i];
auto &b = unsorted[j];
(((a) >= (b)) || (((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b))));
}
std::cout << unsorted ;
Notice that the comparison and swap happens without any branching and arithmetic operations. There are only comparison and bitwise operations done.

Answer 3

How about this one?
#include <iostream>
int main()
{
int digit[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned int input = 12823745;
unsigned int output = 0;
while(input > 0) {
digit[input % 10]++;
input /= 10;
}
for(int i = 9; i >= 0; --i) {
while(digit[i] > 0) {
output = output * 10 + i;
digit[i]--;
}
}
std::cout << output;
}