Сортировка массива по диагонали

Если вы можете преобразовать из 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
    }
}

PS Если вы хотите быть действительно умным, я уверен, что вы можете сделать математическую (неитеративную) функцию, которая преобразуется из индекса в Brray в пара индексов в Array и наоборот. Затем вы можете применить сортировку пузырьков на месте. Но это немного сложнее, чем я хочу разобраться сейчас. Тем не менее, вы можете получить дополнительный кредит.

Реализация PPS на следующее утро: вы можете использовать этот подход для реализации сортировки пузырьков непосредственно в 2D-массиве. Нет необходимости в копировании. Подумайте об этом так: если вы знаете пару координат (x; y), вы можете легко вычислить следующую (x; y) координату в списке. Таким образом, вы можете перемещаться вперед по массиву из любой точки. В любом случае, это все зависит от типа пузырьков.

Спасибо за вашу помощь всем, что вы сказали, было очень полезно для меня. Я на самом деле смог четко подумать и придумал способ начать заполнение массива на основе вашей рекомендации, но сейчас одна проблема, я почти уверен, что моя логика на 99% правильная, но где-то есть недостаток. После запуска моего кода 2-й массив не печатается на экране. Любая помощь в этом?

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

Еще раз спасибо за помощь

Следующее может помочь вам:

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

Храните "диагонально отсортированные" числа в массиве и используйте это, чтобы отобразить отсортированный массив. Для удобства, предположите, что индексирование на основе 0:

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

Затем переместите этот массив и покажите как

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

Обратите внимание, что проще, если ваш отсортированный Array по-прежнему остается одномерным на этом этапе. Вы добавляете второе измерение только при печати.