Question

我想问一下如何使用位移操作按大小对整数数字进行排序。这是一个例子：

Input : 12823745
Output : 87543221

基本上将数字从高位数字排序到小数位我听说可以不使用Bubblesort / Quicksort算法，但可以使用一些位移操作。

有人知道如何实现这一目标吗？

Answer 1

快速排序和冒泡排序是通用算法。因此，不对要排序的数据做出任何假设。但是，每当我们获得有关数据的其他信息时，我们就可以使用它来获得不同的东西（我不是说更好/更快或类似的东西，因为它很难比简单和强大的东西更快，如快速/冒泡排序和它真的取决于你需要的具体情况。）

如果只有有限数量的元素要排序（只有10个不同的数字），可以使用以下内容：

#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;
}

请注意，这具有复杂度O（N）。此外，当可能的元素集具有有限的大小时（不仅对于数字而且对于浮点数而言），这始终有效。不幸的是，它只适用于非常小的尺寸。

有时只计算元素是不够的。除了必须排序的值之外，它们可能具有一些标识。但是，在这种情况下，上述内容也可以很容易地修改（需要相当多的副本，但仍然是O（n））。

实际上我不知道如何通过使用bitshift操作来解决您的问题。但是，我只想指出，当您的数据具有良好的属性时，总有一种方法不使用通用算法（有时甚至可以提高效率）。

Answer 2

这是一个解决方案 - 使用循环和按位操作实现冒泡排序。

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 ;

请注意，比较和交换没有任何分支和算术运算。只进行了比较和按位操作。

Answer 3

这个怎么样？

#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;
}

C ++使用位移操作排序编号

3 个答案: