对角排序数组

时间：2014-01-03 23:12:32

标签： c++ arrays sorting

我查了一些网站，但找不到问题的答案。

这是我的代码：

#include "stdafx.h"
#include <iostream>
#include <math.h>
#include <time.h>
#include<iomanip>
#include<array>
#include <algorithm>

using namespace std;
const int AS = 6;
int filling(void);
void printing(int[AS][AS]);
int forsorting(int[][AS], int);


int main()

{
    int funny = 0;
    int timpa = 0;
    int counter = 0;
    int Array[AS][AS];
    srand(time(0));

    for (int i = 0; i<AS; i++)
    {
        for (int j = 0; j<AS; j++)
            Array[i][j] = filling();
    }

    cout << "The unsorted array is" << endl << endl;

    printing(Array);


    cout << "The sorted array is" << endl << endl;



    for (int il = 0; il<AS; il++)
    {
        for (int elle = 0; elle<AS; elle++)
            Array[il][elle] =forsorting(Array, funny);

        printing(Array);

    }

    system("PAUSE");


    return 0;

}

int filling(void)
{
    int kira;
    kira = rand() % 87 + 12;
    return kira;
}


void printing(int Array[AS][AS])
{
    int counter = 0;
    for (int i = 0; i<AS; i++)
    {
        for (int j = 0; j<AS; j++)
        {
            cout << setw(5) << Array[i][j];
            counter++;
            if (counter%AS == 0)
                cout << endl << endl;
        }
    }
}

int forsorting(int Array[AS][AS], int funny)
{
    int c, tmp, x;
    int dice = 0;
    int Brray[AS*AS];
    int timpa = 0;
    int super = 0;


    //Transofrming Array[][] into Brray[]
    for (int i = 0; i < AS; i++)
    {
        for (int k = 0; k < AS; k++)
        {
            Brray[timpa] = Array[i][k];
            timpa++;
        }
    }


    //Bubble sorting in Brray[]

    for (int passer = 1; passer <= AS-1; passer++)
    {
        for (int timon = 1; timon <= AS-1; timon++)
        {
            if (Brray[timpa]>Brray[timpa + 1])
            {
                super = Brray[timpa];
                Brray[timpa] = Brray[timpa + 1];
                Brray[timpa + 1] = super;
            }
        }
    }

    //Transforming Brray[] into Array[][]

    for (int e = 0; e<AS; e++)
    {
        for (int d = 0; d<AS; d++)
        {
            Brray[dice] = Array[e][d];

            dice++;
        }
    }

    ***There's a part missing here***


}

我要做的是，使用3个函数编写程序。

  • 第一个函数将随机填充我的2D数组（此部分没有问题）
  • 第二个函数会在屏幕上打印未排序的数组（此部分没问题）
  • 并且第3个函数将对角排序我的数组，如下图所示：

Sample

然后我需要调用第二个函数来打印排序的数组。我的问题是第三个函数我将我的2D数组转换为一维数组并使用冒泡排序对其进行排序，但我不能做的是将其转换为对角排序的二维数组。

5 个答案:

答案 0 :(得分：1)

如果您可以从2D阵列转换为1D阵列，那么转换回来是相反的过程。采取相同的循环并改变任务。

但是在你的情况下，转换本身是错误的。它应该采用顺序（0; 0），（0; 1），（1; 0）的索引。但它的作用是按顺序（0; 0），（0; 1），（1; 1）采用索引。

我的建议是使用每个对角线上X和Y坐标之和相同的事实，它从0到AS * 2-2。

然后使用另一个循环，您可以检查所有可能的有效x / y组合。像这样：

for ( int sum = 0; sum < AS*2-1; sum++ )
{
    for ( int y = sum >= AS ? sum-AS+1 : 0; y < AS; y++ )
    {
        x = sum - y;
        // Here assign either from Array to Brray or from Brray to Array
    }
}

P.S。如果你想变得非常聪明，我很确定你可以创建一个数学（非迭代）函数，它将Brray中的索引转换为Array中的索引对，反之亦然。然后，您可以应用冒泡排序。但这比我现在愿意弄清楚的要复杂一点。不过，你可能会获得额外的荣誉。

P.P.S。第二天早上实现：您可以使用此方法直接在2D数组中实现冒泡排序。无需复制。可以这样想：如果你知道一对（x; y）坐标，你可以很容易地找出列表上的下一个（x; y）坐标。所以你可以从任何一点向前移动数组。无论如何，这就是所有泡沫排序需求。

答案 1 :(得分：0)

将“对角排序的”数字存储到数组中，并使用它来显示已排序的数组。为方便起见，假设基于0的索引：

char order[] = { 0, 1, 3, 6, 10, 2, 4, 7, 11, 15, .. (etc)

然后遍历此数组并显示为

printf ("%d", Array[order[x]]);

请注意，如果您在此步骤中排序的Array仍然是一维的，则会更容易。只有在打印时才会添加第二个维度。

答案 2 :(得分：0)

假设您有一个基于0的1维数组A个n = m^2元素。我将告诉你如何根据你的对角化方法得到A的索引和一对二维数组的索引。我将在i中调用A（基于0的）索引，并在2D数组中调用x和y（基于0的）索引。

首先，我们假设我们知道x和y。包含(x,y)的对角线中的所有条目具有相同的坐标总和。让sum = x + y。在你到达包含这个条目的对角线之前，你通过sum之前的对角线迭代（检查这是正确的，因为从零开始索引）。具有总和k的对角线具有总共k + 1个条目。因此，在进入此对角线之前，您将遍历1 + 2 + ... + (sum - 1)个条目。有一个1 + 2 + ... + N形式总和的公式，即N * (N + 1) / 2。因此，在进入此对角线之前，您会遍历(sum - 1) * sum / 2个条目。

现在，在进入(x,y)的条目之前，你在这个对角线上经历了一些条目，不是吗？多少？为什么，这正是y！您从顶部条目开始，一次下降一个。因此，(x,y)处的条目是((sum - 1) * sum / 2 + y + 1)条目，但该数组也是从零开始的，因此我们需要减去一个。所以，我们得到公式：

  • i = (sum - 1) * sum / 2 + y = (x + y - 1) * (x + y) / 2 + y

要向后移动，我们希望从i开始，并找出元素(x,y)所在的2D数组中的A[i]对。因为我们正在解决两个变量（x和y）从一个（只是i）和一个约束开始，所以写下一个封闭的公式是比较棘手的。事实上，我不相信封闭的形式是可能的，当然也不是没有一些floor等等。我开始试图找到一个并放弃！祝你好运！

在递增(x,y)时迭代生成i对可能是正确且更容易的，请记住坐标对的总和在一个对角线内是恒定的。

答案 3 :(得分：0)

以下内容可以帮助您：

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

template<typename T>
class DiagArray
{
public:
    DiagArray(int size) : width(size), data(size * size), orders(size * size)
    {
        buildTableOrder(size);
    }

    const T& operator() (int x, int y) const { return data[orders[width * y + x]]; }
    T& operator() (int x, int y) { return data[orders[width * y + x]]; }

    void sort() { std::sort(data.begin(), data.end()); }

    void display() const {
        int counter = 0;

        for (auto index : orders) {
            std::cout << std::setw(5) << data[index];
            counter++;
            if (counter % width == 0) {
                std::cout << std::endl;
            }
        }
    }

private:
    void buildTableOrder(int size)
    {
        int diag = 0;
        int x = 0;
        int y = 0;
        for (int i = 0; i != size * size; ++i) {
            orders[y * size + x] = i;
            ++y;
            --x;
            if (x < 0 || y >= size) {
                ++diag;
                x = std::min(diag, size - 1);
                y = diag - x;
            }
        }
    }

private:
    int width;
    std::vector<T> data;
    std::vector<int> orders;
};

int main(int argc, char *argv[])
{
    const int size = 5;
    DiagArray<int> da(size);

    for (int y = 0; y != size; ++y) {
        for (int x = 0; x != size; ++x) {
            da(x, y) = size * y + x;
        }
    }
    da.display();
    std::cout << std::endl;
    da.sort();
    da.display();
    return 0;
}

答案 4 :(得分：0)

感谢大家的帮助，你说的对我来说非常有用。我实际上能够清楚地思考并想出了一种方法来根据你的建议开始填充阵列，但现在有一个问题，我很确定我的逻辑是99％正确但是某处存在缺陷。运行我的代码后，第二个数组没有打印在屏幕上。对此有何帮助？

#include "stdafx.h"
#include <iostream>
#include <math.h>
#include <time.h>
#include<iomanip>
#include<array>
#include <algorithm>

using namespace std;
const int AS = 5;
int filling(void);
void printing(int[AS][AS]);
int forsorting(int[][AS], int);


int main()

{
    int funny = 0;
    int timpa = 0;
    int counter = 0;
    int Array[AS][AS];
    srand(time(0));

    for (int i = 0; i<AS; i++)
    {
        for (int j = 0; j<AS; j++)
            Array[i][j] = filling();
    }

    cout << "The unsorted array is" << endl << endl;

    printing(Array);


    cout << "The sorted array is" << endl << endl;



    for (int il = 0; il<AS; il++)
    {
        for (int elle = 0; elle<AS; elle++)
            Array[il][elle] =forsorting(Array, funny);



    }
    printing(Array);
    system("PAUSE");


    return 0;

}

int filling(void)
{
    int kira;
    kira = rand() % 87 + 12;
    return kira;
}


void printing(int Array[AS][AS])
{
    int counter = 0;
    for (int i = 0; i<AS; i++)
    {
        for (int j = 0; j<AS; j++)
        {
            cout << setw(5) << Array[i][j];
            counter++;
            if (counter%AS == 0)
                cout << endl << endl;
        }
    }
}

int forsorting(int Array[AS][AS], int funny)
{int n;
    int real;
    int dice = 0;
    int Brray[AS*AS];
    int timpa = 0;
    int super = 0;
    int median;
    int row=0;
    int col=AS-1;


    //Transofrming Array[][] into Brray[]
    for (int i = 0; i < AS; i++)
    {
        for (int k = 0; k < AS; k++)
        {
            Brray[timpa] = Array[i][k];
            timpa++;
        }
    }


    //Bubble sorting in Brray[]

    for (int passer = 1; passer <= AS-1; passer++)
    {
        for (int timon = 1; timon <= AS-1; timon++)
        {
            if (Brray[timpa]>Brray[timpa + 1])
            {
                super = Brray[timpa];
                Brray[timpa] = Brray[timpa + 1];
                Brray[timpa + 1] = super;
            }
        }
    }

    //Transforming Brray[] into sorted Array[][]


    for(int e=4;e>=0;e--)//e is the index of the diagonal we're working in
    {


        if(AS%2==0)
            {median=0.5*(Brray[AS*AS/2]+Brray[AS*AS/2-1]);
        //We start filling at median - Brray[AS*AS/2-1]

        while(row<5 && col>=0)

            {real=median-Brray[AS*AS/2-1];
        Array[row][col]=Brray[real];
        real++;
        col--;
        row++;}
        }

        else {
            median=Brray[AS*AS/2];
            //We start filling at Brray[AS*AS/2-AS/2]

            while(row<5 && col>=0)
            {real=Brray[AS*AS/2-AS/2];
            n=Array[row][col]=Brray[real];
        real++;
        col--;
        row++;}

        }

    }



    return n;
}

再次感谢您的协助

相关问题
最新问题