Question

是否有一种算法可以帮助对左表（对于标量或对象的多维数组的抽象）进行排序，因此结果将如右图所示，因为可能存在有限的可用深度在右表中（例如最多30行）？

问题稍微复杂一点（单元格中的第一个键优先于另一个键）：

编辑：另一个复杂程度（如果可以安全地合并行/级别以防止冗余）：

Answer 1

可能的解决办法是：

#include <vector>
#include <iostream>
#include <algorithm>

using Column = std::vector<int>;
using Matrix = std::vector<Column>;

Column max_col(const Matrix &m) {
    return *std::max_element(m.begin(), m.end(),
                             [](auto& lhs, auto& rhs)
                             {
                                 return lhs.size() < rhs.size();
                             });
}

bool is_element_in_next_rows(const Matrix &m, int element,Column::size_type row) {
    for (auto& col : m) {
        if (row >= col.size()) continue; // out of range
        if (*std::lower_bound(col.begin()+row+1,col.end(),element) == element) {
            return true;
        }
    }
    return false;
}

int min_element_in_row(const Matrix &m, Column::size_type row) { 
    int min_element = max_col(m)[row];
    for (auto& col : m) {
        if (row >= col.size()) continue; // out of range
        if (col[row] != 0) min_element = std::min(min_element, col[row]);
    }
    return min_element;
}

void print_elements(const Matrix &m) {
    for (auto& i : m) {
        for (auto& j : i) {
            std::cout << j << " ";
        }
        std::cout << std::endl;
    }
}

void organize_elements(Matrix &m) {
    for (auto& col : m) {
        std::sort(col.begin(),col.end());
    }
    auto current_max_col = max_col(m);
    for (Column::size_type row{0}; current_max_col.begin()+row!=current_max_col.end(); ++row) {
        int min_element = min_element_in_row(m,row);
        for(auto& col : m) {
            if (row >= col.size()) continue; // out of range
            int candidate = col[row];
            if (candidate > min_element) {
                if (is_element_in_next_rows(m,candidate,row)) {
                    col.insert(col.begin()+row,0);
                }
            }
        }
        current_max_col = max_col(m);
    }
}

int main() {

    Column c1 = {5,6,8};
    Column c2 = {2,5,3,1,4,6};
    Column c3 = {8,7,2,4,5,3,1};

    Matrix m;
    m.push_back(c1);
    m.push_back(c2);
    m.push_back(c3);

    std::cout << "original: \n";
    print_elements(m);
    organize_elements(m);
    std::cout << "organized: \n";
    print_elements(m);
    return 0;
}

输出以下内容：

original: 
5 6 8 
7 2 5 3 1 4 6 
8 7 2 4 5 3 1 
organized: 
0 0 0 0 5 6 8 
1 2 3 4 5 6  
1 2 3 4 5 7 8

包括对很容易，只需改变比较函数的执行方式。我不知道这是不是你的意思。它还可以进一步优化，这是一个快速的解决方案，可以满足您的需求或激励您做一个更好的。

Answer 2

每列中的元素是否与列的深度有关？如果是这样，只需迭代多维数组的每一列，并将元素放在相应的行中。如果您分配更多内存或者可以使用交换（仍然是O（n））来执行此操作，这很简单。您可以在事后应用更复杂的分组。

表格单元格/ 2d数组排序算法

2 个答案: