poszypszenie sortowania mojego

około 90% obliczeń mojego programu to funkcja sortowania nie wiem jak by ją szło poszybszyć :

void sortowanie2_dla_tabszablonow2(int n,int aktualna_karta_do_gry,int nr_tab_szablonu)
{
	float Start1 = GetTickCount();
	float End1=0.0;
	float czas1=0.0;
// cout<<"w sortowaniu przed posortowaniem"<<endl;
int position;
float min;
float temp;
for ( int ii = 0; ii < n-1; ++ii )
{

// if(ii%10000==0)
// {
//cout<<endl<<"		"<<ii;
//}
min = tab_tymczasowa_zapamietujaca_zmienne2[ii][0];
position = ii;
for ( int j = ii+1; j < n; ++j )
{
if ( tab_tymczasowa_zapamietujaca_zmienne2[j][0] < min )
{
min = tab_tymczasowa_zapamietujaca_zmienne2[j][0];
position = j;
}
}
temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][0];
tab_tymczasowa_zapamietujaca_zmienne2[ii][0] = min;
tab_tymczasowa_zapamietujaca_zmienne2[position][0] = temp;
/*
temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][1];
tab_tymczasowa_zapamietujaca_zmienne2[ii][1] = tab_tymczasowa_zapamietujaca_zmienne2[position][1];
tab_tymczasowa_zapamietujaca_zmienne2[position][1] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][2];
tab_tymczasowa_zapamietujaca_zmienne2[ii][2] = tab_tymczasowa_zapamietujaca_zmienne2[position][2];
tab_tymczasowa_zapamietujaca_zmienne2[position][2] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][3];
tab_tymczasowa_zapamietujaca_zmienne2[ii][3] = tab_tymczasowa_zapamietujaca_zmienne2[position][3];
tab_tymczasowa_zapamietujaca_zmienne2[position][3] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][4];
tab_tymczasowa_zapamietujaca_zmienne2[ii][4] = tab_tymczasowa_zapamietujaca_zmienne2[position][4];
tab_tymczasowa_zapamietujaca_zmienne2[position][4] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][5];
tab_tymczasowa_zapamietujaca_zmienne2[ii][5] = tab_tymczasowa_zapamietujaca_zmienne2[position][5];
tab_tymczasowa_zapamietujaca_zmienne2[position][5] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][6];
tab_tymczasowa_zapamietujaca_zmienne2[ii][6] = tab_tymczasowa_zapamietujaca_zmienne2[position][6];
tab_tymczasowa_zapamietujaca_zmienne2[position][6] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][7];
tab_tymczasowa_zapamietujaca_zmienne2[ii][7] = tab_tymczasowa_zapamietujaca_zmienne2[position][7];
tab_tymczasowa_zapamietujaca_zmienne2[position][7] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][8];
tab_tymczasowa_zapamietujaca_zmienne2[ii][8] = tab_tymczasowa_zapamietujaca_zmienne2[position][8];
tab_tymczasowa_zapamietujaca_zmienne2[position][8] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][9];
tab_tymczasowa_zapamietujaca_zmienne2[ii][9] = tab_tymczasowa_zapamietujaca_zmienne2[position][9];
tab_tymczasowa_zapamietujaca_zmienne2[position][9] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][10];
tab_tymczasowa_zapamietujaca_zmienne2[ii][10] = tab_tymczasowa_zapamietujaca_zmienne2[position][10];
tab_tymczasowa_zapamietujaca_zmienne2[position][10] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][11];
tab_tymczasowa_zapamietujaca_zmienne2[ii][11] = tab_tymczasowa_zapamietujaca_zmienne2[position][11];
tab_tymczasowa_zapamietujaca_zmienne2[position][11] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][12];
tab_tymczasowa_zapamietujaca_zmienne2[ii][12] = tab_tymczasowa_zapamietujaca_zmienne2[position][12];
tab_tymczasowa_zapamietujaca_zmienne2[position][12] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][13];
tab_tymczasowa_zapamietujaca_zmienne2[ii][13] = tab_tymczasowa_zapamietujaca_zmienne2[position][13];
tab_tymczasowa_zapamietujaca_zmienne2[position][13] = temp;

temp = tab_tymczasowa_zapamietujaca_zmienne2[ii][14];
tab_tymczasowa_zapamietujaca_zmienne2[ii][14] = tab_tymczasowa_zapamietujaca_zmienne2[position][14];
tab_tymczasowa_zapamietujaca_zmienne2[position][14] = temp;
*/
  }

    //////////////////////////////////////////////////////////////////////////////////////////////////////////
	//zapisanie_do_zmiennej_przejsciowej_najlepszej_konfiguracji:
int nn=0;
nn=n-1;
		tab_temp_reka_2[0]=tab_tymczasowa_zapamietujaca_zmienne2[nn][0];//najwazniejsze
		tab_temp_reka_2[1]=tab_tymczasowa_zapamietujaca_zmienne2[nn][1];
		tab_temp_reka_2[2]=tab_tymczasowa_zapamietujaca_zmienne2[nn][2];
		//tab_temp_reka_2[3]=tab_tymczasowa_zapamietujaca_zmienne2[4494][3];//ale w grze ilosc kart=ilosc kart-1 !!!
		tab_temp_reka_2[3]=tab_temp_reka_2[3]-1;
		
		if(aktualna_karta_do_gry==1&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[13]=tab_temp_reka_2[13]-1;
		}
		if(aktualna_karta_do_gry==2&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[4]=tab_temp_reka_2[4]-1;
		}
		if(aktualna_karta_do_gry==3&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[5]=tab_temp_reka_2[5]-1;
		}
		if(aktualna_karta_do_gry==4&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[6]=tab_temp_reka_2[6]-1;
		}
		if(aktualna_karta_do_gry==5&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[7]=tab_temp_reka_2[7]-1;
		}
		if(aktualna_karta_do_gry==6&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[8]=tab_temp_reka_2[8]-1;
		}
		if(aktualna_karta_do_gry==7&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[9]=tab_temp_reka_2[9]-1;
		}
		if(aktualna_karta_do_gry==8&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[10]=tab_temp_reka_2[10]-1;
		}
		if(aktualna_karta_do_gry==9&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[11]=tab_temp_reka_2[11]-1;
		}
		if(aktualna_karta_do_gry==10&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[12]=tab_temp_reka_2[12]-1;
		}
		if(aktualna_karta_do_gry==11&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[13]=tab_temp_reka_2[13]-1;
		}
		if(aktualna_karta_do_gry==75&&tab_temp_reka_2[0]>0)
		{
		tab_temp_reka_2[14]=tab_temp_reka_2[14]-1;
		}
		
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
		int index=0;
/*		cout<<endl<<endl<<"          top 10 wynikow dla aktualnej kombincaji :  "<<endl<<endl;
		Sleep(4000);


		for(int nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry=nn;nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry>(nn-10);nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry--)
		{
		index=tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][2];
		cout<<endl<<endl<<"  nr tablicy glownej= "<<tab_tymczasowa_zapamietujaca_zmienne2[index][1]<<endl;
		cout<<"  k= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][2]<<endl;	

		if(nr_tab_szablonu==1)
		{
		cout<<"tabszablonow1["<<index<<"]={"<<tabszablonow1[index][0]<<","<<tabszablonow1[index][1]<<","<<tabszablonow1[index][2]<<","<<tabszablonow1[index][3]<<","<<tabszablonow1[index][4]<<"}"<<endl;
		}
		if(nr_tab_szablonu==2)
		{
		cout<<"tabszablonow2["<<index<<"]={"<<tabszablonow2[index][0]<<","<<tabszablonow2[index][1]<<","<<tabszablonow2[index][2]<<","<<tabszablonow2[index][3]<<","<<tabszablonow2[index][4]<<"}"<<endl;
		}	
		if(nr_tab_szablonu==3)
		{
		cout<<"tabszablonow3["<<index<<"]={"<<tabszablonow3[index][0]<<","<<tabszablonow3[index][1]<<","<<tabszablonow3[index][2]<<","<<tabszablonow3[index][3]<<","<<tabszablonow3[index][4]<<"}"<<endl;
		}	
		if(nr_tab_szablonu==4)
		{
		cout<<"tabszablonow4["<<index<<"]={"<<tabszablonow4[index][0]<<","<<tabszablonow4[index][1]<<","<<tabszablonow4[index][2]<<","<<tabszablonow4[index][3]<<","<<tabszablonow4[index][4]<<"}"<<endl;
		}	
		if(nr_tab_szablonu==5)
		{
		cout<<"tabszablonow5["<<index<<"]={"<<tabszablonow5[index][0]<<","<<tabszablonow5[index][1]<<","<<tabszablonow5[index][2]<<","<<tabszablonow5[index][3]<<","<<tabszablonow5[index][4]<<"}"<<endl;
		}	
		if(nr_tab_szablonu==6)
		{
		cout<<"tabszablonow6["<<index<<"]={"<<tabszablonow6[index][0]<<","<<tabszablonow6[index][1]<<","<<tabszablonow6[index][2]<<","<<tabszablonow6[index][3]<<","<<tabszablonow6[index][4]<<"}"<<endl;
		}	
		if(nr_tab_szablonu==7)
		{
		cout<<"tabszablonow7["<<index<<"]={"<<tabszablonow7[index][0]<<","<<tabszablonow7[index][1]<<","<<tabszablonow7[index][2]<<","<<tabszablonow7[index][3]<<","<<tabszablonow7[index][4]<<"}"<<endl;
		}	
		if(nr_tab_szablonu==8)
		{
		cout<<"tabszablonow8["<<index<<"]={"<<tabszablonow8[index][0]<<","<<tabszablonow8[index][1]<<","<<tabszablonow8[index][2]<<","<<tabszablonow8[index][3]<<","<<tabszablonow8[index][4]<<"}"<<endl;
		}	
		if(nr_tab_szablonu==9)
		{
		cout<<"tabszablonow9["<<index<<"]={"<<tabszablonow9[index][0]<<","<<tabszablonow9[index][1]<<","<<tabszablonow9[index][2]<<","<<tabszablonow9[index][3]<<","<<tabszablonow9[index][4]<<"}"<<endl;
		}	
		if(nr_tab_szablonu==10)
		{
		cout<<"tabszablonow10["<<index<<"]={"<<tabszablonow10[index][0]<<","<<tabszablonow10[index][1]<<","<<tabszablonow10[index][2]<<","<<tabszablonow10[index][3]<<","<<tabszablonow10[index][4]<<"}"<<endl;
		}	
		if(nr_tab_szablonu==11)
		{
		cout<<"tabszablonow11["<<index<<"]={"<<tabszablonow11[index][0]<<","<<tabszablonow11[index][1]<<","<<tabszablonow11[index][2]<<","<<tabszablonow11[index][3]<<","<<tabszablonow11[index][4]<<"}"<<endl;
		}	
		if(nr_tab_szablonu==75)
		{
		cout<<"tabspecialblackjack12["<<index<<"]={"<<tabspecialblackjack12[index][0]<<","<<tabspecialblackjack12[index][1]<<","<<tabspecialblackjack12[index][2]<<","<<tabspecialblackjack12[index][3]<<","<<tabspecialblackjack12[index][4]<<"}"<<endl;
		}			 
			  //cout<<"AA= "<<AA<<endl;
		cout<<"ile_kart_pozostalo_do_grania= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][3]<<endl;
		//cout<<"tab_ile_kart_w_grze_reka_2[9]= "<<tab_ile_kart_w_grze_reka_2[9]<<endl;
		cout<<"prawdopodobienstwo_tabszablonow_reka_2= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][0]<<endl<<endl;
		cout<<"tab_ile_kart_w_grze_reka_2[0] (2)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][4]<<endl;
		cout<<"tab_ile_kart_w_grze_reka_2[1] (3)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][5]<<endl;
		cout<<"tab_ile_kart_w_grze_reka_2[2] (4)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][6]<<endl;
		cout<<"tab_ile_kart_w_grze_reka_2[3] (5)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][7]<<endl;
		cout<<"tab_ile_kart_w_grze_reka_2[4] (6)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][8]<<endl;
		cout<<"tab_ile_kart_w_grze_reka_2[5] (7)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][9]<<endl;
		cout<<"tab_ile_kart_w_grze_reka_2[6] (8)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][10]<<endl;
		cout<<"tab_ile_kart_w_grze_reka_2[7] (9)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][11]<<endl;
		cout<<"tab_ile_kart_w_grze_reka_2[8] (10,j,Q,K)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][12]<<endl;
		cout<<"2tab_ile_kart_w_grze_reka_2[9] (As)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][13]<<endl;
		cout<<"tab_ile_kart_w_grze_reka_2[10] (black_j)= "<<tab_tymczasowa_zapamietujaca_zmienne2[nelement_tablicy_w_ktorym_zapisana_jest_ilosc_kart_aktualna_karta_do_gry][14]<<endl;
		Sleep(200);
		system("pause");
		}
*/
End1 = GetTickCount();
czas1=(End1-Start1);
cout<<endl<<endl<<"czas1 = "<<czas1<<endl<<endl;
Sleep(2000);
system("pause");
} 

ten temat powinien być raczej w tym temacie: http://4programmers.net/Forum/Off-Topic/141606-Najwi%C4%99ksze_programistyczne_WTF_jakie_Was_spotka%C5%82o

Po pierwsze - naucz się formatować kod.
Po drugie - póki go nie sformatujesz nikt Ci nie pomoże, ponieważ nie widać, co gdzie jest.
Po trzecie - nazwy zmiennych :|
Po czwarte system("pause"); to zło!
Po piąte - "poszypszenie", "poszybszyć" - brak słów... Wracaj do podstawówki :P

jedynym sposobem na "poszybszenie" Twojego kodu jest napisanie go od nowa, tylko nie "klep" na siłę kodu, postaraj sie to jakoś formatować.

to jest ten sam kod do optymalizacji:

globalna tablica:
static float tab_tymczasowa_zapamietujaca_zmienne2[5737][15];

tu jest gotowy program do kompilacji króty wykonuje się średnio 100 ms

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
#include <windows.h>
#include <Shellapi.h>
#include <fstream>

using namespace std;
void sortowanie2_dla_tabszablonow2();
static int  tablica[5737][15];

int _tmain(int argc, _TCHAR* argv[])
{

 srand((int) time(0));
 
	 for(int i=0;i<5737;i++)
	 {
		for(int j=0;j<15;j++)
		{
		tablica[i][j]=rand()%3000;
		//cout<<"tablica["<<i<<"][j]="<<tablica[i][j]<<endl;
		}
	 }



sortowanie2_dla_tabszablonow2();


	return 0;
}


void sortowanie2_dla_tabszablonow2()
{      
        int n=5737;
        float Start1 = GetTickCount();
        float End1=0.0;
        float czas1=0.0;
        int position;
        int min;
        int temp;
 
for ( int ii = 0; ii < n-1; ++ii )
{
min = tablica[ii][0];
position = ii;
        for ( int j = ii+1; j < n; ++j )
        {
                if ( tablica[j][0] < min )
                {
                min = tablica[j][0];
                position = j;
                }
        }
temp = tablica[ii][0];
tablica[ii][0] = min;
tablica[position][0] = temp;

temp = tablica[ii][1];
tablica[ii][1] = tablica[position][1];
tablica[position][1] = temp;
}
 
 
End1 = GetTickCount();
czas1=(End1-Start1);
cout<<endl<<endl<<" czas1 = "<<czas1<<"ms"<<endl<<endl;
Sleep(2000);
system("pause");
}  

co zamiast : system("pause"); urzywać

mam szysze sortowanie: możne komuś będzie się chciało to jeszcze zoptymalizować za pomocą użycia jakiś wskaźników lub assemblera?

// sortowanie quicksort.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
#include <windows.h>
#include <Shellapi.h>
#include <fstream>
#include <sys/timeb.h> // pomiar czasu 

using namespace std;
//void sortSzybkie(int *tablica, int lewy, int prawy);  //sortowanie szybkie 
void sortSzybkie(int lewy, int prawy);  //sortowanie szybkie 
double pomiar_czasu(); 
static int  tablica[5737][2];


int _tmain(int argc, _TCHAR* argv[])
{
		double czas_start, czas_stop, czasSzybkie;
		srand((int) time(0));
 
         for(int i=0;i<5737;i++)
         {
                for(int j=0;j<2;j++)
                {
                tablica[i][j]=rand()%3000;
                //cout<<" tablica["<<i<<"][j]= "<<tablica[i][j];
                }
                cout<<endl;
         }
		system("pause");


        float Start1 = GetTickCount();
        float End1=0.0;
        float czas1=0.0;
		czas_start = pomiar_czasu(); 
        //sortSzybkie(tablica,0,wielkosc-1); 
		sortSzybkie(0,5737-1); 		
		czas_stop = pomiar_czasu();
		End1 = GetTickCount();
		czas1=(End1-Start1);
		cout<<endl<<endl<<" czas1 = "<<czas1<<"ms"<<endl<<endl;
		czasSzybkie = czas_stop-czas_start;
		cout << "Czas sortowania szybkiego: " <<czasSzybkie<<endl; 
		Sleep(2000);
		system("pause");
		         for(int i=0;i<5737;i++)
         {
                for(int j=0;j<2;j++)
                {
                cout<<" tablica["<<i<<"][j]= "<<tablica[i][j];
                }
                cout<<endl;
         }
		Sleep(2000);
		system("pause");
	return 0;
}

//-------------------------------------------------------------------------------
//void sortSzybkie(int *tablica, int lewy, int prawy)
void sortSzybkie(int lewy, int prawy)
{
int v=tablica[(lewy+prawy)/2][0];
int i,j,temp;
i=lewy;
j=prawy;
   do{
     while (tablica[i][0]<v) i++;
     while (tablica[j][0]>v) j--;
     if (i<=j){
               temp=tablica[i][0];
               tablica[i][0]=tablica[j][0];
               tablica[j][0]=temp;

               temp=tablica[i][1];
               tablica[i][1]=tablica[j][1];
               tablica[j][1]=temp;

               i++; j--;
     }
   } while (i<=j);
   
   if (j>lewy) sortSzybkie(lewy, j);
   if (i<prawy) sortSzybkie(i, prawy);
   
}
//-------------------------------------------------------------------------------
double pomiar_czasu()
{
   struct timeb czas;
   double wynik;

   // Wypelnij strukture 'czas' biezacym czasem
   ftime(&czas);

   // Teraz mamy:
   // * czas.time - liczba sekund, ktore uplynely od godziny
   //   00:00 czasu GMT dnia 1.01.1970
   // * czas.millitm - offset w milisekundach

   // Skonwertuj czas do typu double
   wynik = (double) czas.time;
   wynik += (double) czas.millitm / 1000.0;

   // Zwroc wynik
   return wynik;
} 

Czemu po prostu nie użyjesz std::sort? Nie nadaje się?

możne komuś będzie się chciało to jeszcze zoptymalizować za pomocą użycia jakiś wskaźników lub assemblera?

Nie ma potrzeby.

jak w tym programie sortować całą tablicę 2 elementową:

już mam czeba jeszcze 1 piv

 


#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
#include <windows.h>
#include <Shellapi.h>
#include <fstream>
#include <sys/timeb.h> // pomiar czasu 
using namespace std;
void quickSort(int *arr, int elements);
double pomiar_czasu(); 
 
int _tmain(int argc, _TCHAR* argv[])
{
        double czas_start, czas_stop, czasSzybkie;
        int  tablica22[10][2];
 
        tablica22[0][0]=36;
        tablica22[1][0]=-326;
        tablica22[2][0]=49;
        tablica22[3][0]=9;
        tablica22[4][0]=66;
        tablica22[5][0]=-30;
        tablica22[6][0]=12;
        tablica22[7][0]=923;
        tablica22[8][0]=-104;
        tablica22[9][0]=2;
 
        tablica22[0][1]=539;
        tablica22[1][1]=-33;
        tablica22[2][1]=23;
        tablica22[3][1]=-54;
        tablica22[4][1]=11;
        tablica22[5][1]=901;
        tablica22[6][1]=3;
        tablica22[7][1]=12;
        tablica22[8][1]=-90;
        tablica22[9][1]=-221;
 
 
        cout << "elementy do posortowania: "<<endl; 
        cout << "tablica22[0][0]: " <<tablica22[0][0]<<endl; 
        cout << "tablica22[1][0]: " <<tablica22[1][0]<<endl; 
        cout << "tablica22[2][0]: " <<tablica22[2][0]<<endl; 
        cout << "tablica22[3][0]: " <<tablica22[3][0]<<endl; 
        cout << "tablica22[4][0]: " <<tablica22[4][0]<<endl; 
        cout << "tablica22[5][0]: " <<tablica22[5][0]<<endl; 
        cout << "tablica22[6][0]: " <<tablica22[6][0]<<endl; 
        cout << "tablica22[7][0]: " <<tablica22[7][0]<<endl; 
        cout << "tablica22[8][0]: " <<tablica22[8][0]<<endl; 
        cout << "tablica22[9][0]: " <<tablica22[9][0]<<endl<<endl; 
        cout << "tablica22[0][1]: " <<tablica22[0][1]<<endl; 
        cout << "tablica22[1][1]: " <<tablica22[1][1]<<endl; 
        cout << "tablica22[2][1]: " <<tablica22[2][1]<<endl; 
        cout << "tablica22[3][1]: " <<tablica22[3][1]<<endl; 
        cout << "tablica22[4][1]: " <<tablica22[4][1]<<endl;
        cout << "tablica22[5][1]: " <<tablica22[5][1]<<endl; 
        cout << "tablica22[6][1]: " <<tablica22[6][1]<<endl; 
        cout << "tablica22[7][1]: " <<tablica22[7][1]<<endl; 
        cout << "tablica22[8][1]: " <<tablica22[8][1]<<endl;
        cout << "tablica22[9][1]: " <<tablica22[9][1]<<endl<<endl;  
        czas_start = pomiar_czasu(); 
        quickSort(&tablica22[0][0],10);
        czas_stop = pomiar_czasu();
        czasSzybkie = czas_stop-czas_start;
        cout << "Czas sortowania szybkiego: " <<czasSzybkie<<endl; 	
        cout << "tablica22[0][0]: " <<tablica22[0][0]<<endl; 
        cout << "tablica22[1][0]: " <<tablica22[1][0]<<endl; 
        cout << "tablica22[2][0]: " <<tablica22[2][0]<<endl; 
        cout << "tablica22[3][0]: " <<tablica22[3][0]<<endl; 
        cout << "tablica22[4][0]: " <<tablica22[4][0]<<endl; 
        cout << "tablica22[5][0]: " <<tablica22[5][0]<<endl; 
        cout << "tablica22[6][0]: " <<tablica22[6][0]<<endl; 
        cout << "tablica22[7][0]: " <<tablica22[7][0]<<endl; 
        cout << "tablica22[8][0]: " <<tablica22[8][0]<<endl; 
        cout << "tablica22[9][0]: " <<tablica22[9][0]<<endl<<endl; 
        cout << "tablica22[0][1]: " <<tablica22[0][1]<<endl; 
        cout << "tablica22[1][1]: " <<tablica22[1][1]<<endl; 
        cout << "tablica22[2][1]: " <<tablica22[2][1]<<endl; 
        cout << "tablica22[3][1]: " <<tablica22[3][1]<<endl; 
        cout << "tablica22[4][1]: " <<tablica22[4][1]<<endl;
        cout << "tablica22[5][1]: " <<tablica22[5][1]<<endl; 
        cout << "tablica22[6][1]: " <<tablica22[6][1]<<endl; 
        cout << "tablica22[7][1]: " <<tablica22[7][1]<<endl; 
        cout << "tablica22[8][1]: " <<tablica22[8][1]<<endl;
        cout << "tablica22[9][1]: " <<tablica22[9][1]<<endl;   
        Sleep(2000);
        system("pause");
 
        return 0;
}
 
////////////////////////////////////////////////////////////////////////////////////////////////
void quickSort(int *arr, int elements) {
 
  #define  MAX_LEVELS  300
 
  int  piv, beg[MAX_LEVELS], end[MAX_LEVELS], i=0, swap ;
  int ilosc_koloumn=2,aktualna_kolumna=0;
  int aktualny_wiersz1=0,aktualny_wiersz2=0;
  int IK=ilosc_koloumn,AK=aktualna_kolumna;
  int R=aktualny_wiersz1,L=aktualny_wiersz2;
  beg[0]=0; end[0]=elements;
  while (i>=0) {
    L=beg[i]; R=end[i]-1;
    if (L<R) {
      piv=arr[IK * L + AK];
      while (L<R) {
		  while (arr[IK * R + AK]>=piv && L<R) R--; if (L<R) {
        cout << "(arr[IK * R + AK]>=piv && L<R)"<< " piv=: " <<piv<<endl; 
        cout << "L=: " <<L<<" "<< "R=: " <<R<<endl; 
			  arr[IK * (L++) + AK]=arr[IK * R + AK];		  
        cout << "w  sortowaniu szybkim:1 (if (L<R))"<<endl; 
        cout << "L=: " <<L<<" "<< "R=: " <<R<<endl; 
        cout << "tablica22[0][0]: " <<arr[IK * 0 + 0]<<endl; 
        cout << "tablica22[1][0]: " <<arr[IK * 1 + 0]<<endl; 
        cout << "tablica22[2][0]: " <<arr[IK * 2 + 0]<<endl; 
        cout << "tablica22[3][0]: " <<arr[IK * 3 + 0]<<endl; 
        cout << "tablica22[4][0]: " <<arr[IK * 4 + 0]<<endl;
        cout << "tablica22[5][0]: " <<arr[IK * 5 + 0]<<endl; 
        cout << "tablica22[6][0]: " <<arr[IK * 6 + 0]<<endl; 
        cout << "tablica22[7][0]: " <<arr[IK * 7 + 0]<<endl; 
        cout << "tablica22[8][0]: " <<arr[IK * 8 + 0]<<endl; 
        cout << "tablica22[9][0]: " <<arr[IK * 9 + 0]<<endl<<endl;  
        cout << "tablica22[0][1]: " <<arr[IK * 0 + 1]<<endl; 
        cout << "tablica22[1][1]: " <<arr[IK * 1 + 1]<<endl; 
        cout << "tablica22[2][1]: " <<arr[IK * 2 + 1]<<endl; 
        cout << "tablica22[3][1]: " <<arr[IK * 3 + 1]<<endl; 
        cout << "tablica22[4][1]: " <<arr[IK * 4 + 1]<<endl; 
        cout << "tablica22[5][1]: " <<arr[IK * 5 + 1]<<endl; 
        cout << "tablica22[6][1]: " <<arr[IK * 6 + 1]<<endl; 
        cout << "tablica22[7][1]: " <<arr[IK * 7 + 1]<<endl; 
        cout << "tablica22[8][1]: " <<arr[IK * 8 + 1]<<endl; 
        cout << "tablica22[9][1]: " <<arr[IK * 9 + 1]<<endl<<endl; 
        //Sleep(2000);
        system("pause");
		  L--;arr[IK * (L++) + 1]=arr[IK * R + 1];
		  }//arr[IK * R + AK]-->tab 2 wymiarowa
		  while (arr[IK * L + AK]<=piv && L<R) L++; if (L<R) {
        cout << "(arr[IK * L + AK]<=piv && L<R)"<< " piv=: " <<piv<<endl; 
        cout << "L=: " <<L<<" "<< "R=: " <<R<<endl; 
			  arr[IK * (R--) + AK]=arr[IK * L + AK];		  
        cout << "w  sortowaniu szybkim:2 (if (L<R))"<<endl; 
        cout << "L=: " <<L<<" "<< "R=: " <<R<<endl; 
        cout << "tablica22[0][0]: " <<arr[IK * 0 + 0]<<endl; 
        cout << "tablica22[1][0]: " <<arr[IK * 1 + 0]<<endl; 
        cout << "tablica22[2][0]: " <<arr[IK * 2 + 0]<<endl; 
        cout << "tablica22[3][0]: " <<arr[IK * 3 + 0]<<endl; 
        cout << "tablica22[4][0]: " <<arr[IK * 4 + 0]<<endl;
        cout << "tablica22[5][0]: " <<arr[IK * 5 + 0]<<endl; 
        cout << "tablica22[6][0]: " <<arr[IK * 6 + 0]<<endl; 
        cout << "tablica22[7][0]: " <<arr[IK * 7 + 0]<<endl; 
        cout << "tablica22[8][0]: " <<arr[IK * 8 + 0]<<endl; 
        cout << "tablica22[9][0]: " <<arr[IK * 9 + 0]<<endl<<endl;  
        cout << "tablica22[0][1]: " <<arr[IK * 0 + 1]<<endl; 
        cout << "tablica22[1][1]: " <<arr[IK * 1 + 1]<<endl; 
        cout << "tablica22[2][1]: " <<arr[IK * 2 + 1]<<endl; 
        cout << "tablica22[3][1]: " <<arr[IK * 3 + 1]<<endl; 
        cout << "tablica22[4][1]: " <<arr[IK * 4 + 1]<<endl; 
        cout << "tablica22[5][1]: " <<arr[IK * 5 + 1]<<endl; 
        cout << "tablica22[6][1]: " <<arr[IK * 6 + 1]<<endl; 
        cout << "tablica22[7][1]: " <<arr[IK * 7 + 1]<<endl; 
        cout << "tablica22[8][1]: " <<arr[IK * 8 + 1]<<endl; 
        cout << "tablica22[9][1]: " <<arr[IK * 9 + 1]<<endl<<endl;   
        //Sleep(2000);
        system("pause");
			  R++;arr[IK * (R--) + 1]=arr[IK * L + 1];
		  }}
      arr[IK * L + AK]=piv; beg[i+1]=L+1; end[i+1]=end[i]; end[i++]=L;
      if (end[i]-beg[i]>end[i-1]-beg[i-1]) {
        swap=beg[i]; beg[i]=beg[i-1]; beg[i-1]=swap;
        swap=end[i]; end[i]=end[i-1]; end[i-1]=swap; }}
    else {
      i--; }}}
//-------------------------------------------------------------------------------
double pomiar_czasu()
{
   struct timeb czas;
   double wynik;
 
   // Wypelnij strukture 'czas' biezacym czasem
   ftime(&czas);
 
   // Teraz mamy:
   // * czas.time - liczba sekund, ktore uplynely od godziny
   //   00:00 czasu GMT dnia 1.01.1970
   // * czas.millitm - offset w milisekundach
 
   // Skonwertuj czas do typu double
   wynik = (double) czas.time;
   wynik += (double) czas.millitm / 1000.0;
 
   // Zwroc wynik
   return wynik;
} 
//////////////////////////////////////

Opakuj sobie dane w odpowiednie stuktury, tak żebyś miał jednowymiarową tablicę, czy kolekcję, a potem odpal std::sort

#include <algorithm>

struct struct_t {
    int values[15];
    
    const bool operator<(const struct_t & that) const {
        return values[0] < that.values[0];
    }
};

int main() {

    struct_t tablica[7];
    std::sort(tablica, tablica + 7);

    return 0;
}