Sortowanie macierzy nx3

Witam. Otóż mam taki problem. Zrobiłem sortowanie bąbelkowe macierzy o wymiarach nx3. Działa ono poprawnie. Ale jest zbyt wolne i muszę zmienić je na quicksort bądź inny algorytm szybszy od obecnego.

void sortuj_liste_krawedzi ()
            {	
				int temp3;
				int temp1;
				int temp2;
				
        		for (int i = 0; i<liczba_krawedzi; i++)
        		{
                	for (int j=0; j<liczba_krawedzi-1-i; j++)
                	{
                        if (lista_krawedzi[j][2] > lista_krawedzi[j+1][2])
                        {
                                temp1 = lista_krawedzi[j+1][2];
                                lista_krawedzi[j+1][2] = lista_krawedzi[j][2];
                                lista_krawedzi[j][2] = temp1;
                                temp2 = lista_krawedzi[j+1][1];
                                lista_krawedzi[j+1][1] = lista_krawedzi[j][1];
                                lista_krawedzi[j][1] = temp2;
                                temp3 = lista_krawedzi[j+1][0];
                                lista_krawedzi[j+1][0] = lista_krawedzi[j][0];
                                lista_krawedzi[j][0] = temp3;
                            
                        }
                	}
        		}
				
				
			}

Tutaj jest moja obecna implementacja, czyli sortowanie bąbelkowe. Jakby ktoś potrafił mi pomóc, chociaż podpowiedzieć jak zrobić sortowanie innego typu (preferowane quicksort) wg ostatniej kolumny w tej tablicy dwuwymiarowej to będę wdzięczny. Myślę, że mogę nawet zapłacić osobie, która zechciałaby zrobić takie sortowanie jeżeli zajęłoby to dużo czasu (cena do uzgodnienia).

Podaj deklaracje lista_krawedzi.

bez wątpienia masz źle zdefiniowane indeksy pętli for.
Raczej powinno być tak:

for(int i=0; i<liczba_krawedzi-1; ++i)
for (int j=i+1; j<liczba_krawedzi; j++)

a potem, nie powinno pojawiać się [i+1] ani [j+1].

Więc tak lista krawędzi:

         ///////////////////////////////////////////////////////////////////
          /////////           FUNKCJA TWORZACA LISTE KRAWEDZI             ///
          ////////////////////////////////////////////////////////////////// 
		  void utworz_liste_krawedzi ()
          {	
			// zmienne pomocnicze funkcji
			int wierzch1;
			int wierzch2;
			int waga;
			
			//utworzenie tablicy na liste krawedzi
            lista_krawedzi = new int* [liczba_krawedzi];
            for (int i = 0; i <liczba_krawedzi; i++)
            {
                  lista_krawedzi[i] = new int [3];
            }
		
			if (random)
			{
			
			//zapewnienie spojnosci grafu poprzez polaczenie 1-2-3-....	
			for (int i=0; i<liczba_wierzcholkow-1; i++)
			{	
				srand(i);
				lista_krawedzi[i][0]=i+1;
				lista_krawedzi[i][1]=i+2;
				lista_krawedzi[i][2]=(rand()%10)+1;
			}
			
			if (liczba_krawedzi>=liczba_wierzcholkow)
			{
			
			for (int i=liczba_wierzcholkow-1; i<liczba_krawedzi; i++)
			{	
				srand(i);
				wierzch1=(rand()%liczba_wierzcholkow)+1;
				srand(i*i);
				wierzch2=(rand()%liczba_wierzcholkow)+1;
				
				//wyeliminowanie pętli
				if (wierzch1!=wierzch2) 
								{
									lista_krawedzi[i][0]=wierzch1; //losowy wierzcholek
									lista_krawedzi[i][1]=wierzch2; //losowy wierzcholek
									waga=(rand()%10)+1; //wagi od 1 do 10	
									lista_krawedzi[i][2]=waga;	
								}
							else
								{
									srand(i*i*i);
									wierzch1=(rand()%liczba_wierzcholkow)+1;
									lista_krawedzi[i][0]=wierzch1;
									srand(i*i);
									wierzch2=(rand()%liczba_wierzcholkow)+1;
									lista_krawedzi[i][1]=wierzch2;
									waga=(rand()%10)+1; //wagi od 1 do 10	
									lista_krawedzi[i][2]=waga;
									//i--;
									//srand(i+5);
								}
			}
			}
			}
			
			else 
				{
		 
		   // wypełnienie tablicy danymi z klawiatury
                for (int i=0; i<liczba_krawedzi; i++)
                       {
                        do
                        {
							cout << "Wprowadz wierzcholek poczatkowy: \n";
                        	cin >> wierzch1;
                        	lista_krawedzi[i][0]=wierzch1;
						} while (wierzch1>liczba_wierzcholkow);
						
						do
						{
                        	cout << "\n";
                        	cout << "Wprowadz wierzcholek koncowy: \n";
                        	cin >> wierzch2;
                        	lista_krawedzi[i][1]=wierzch2;
                        } while (wierzch2>liczba_wierzcholkow);
                        
						cout << "\n";
                        cout << "Wprowadz wage krawedzi laczacej wierzcholki " << wierzch1 << " i " << wierzch2 << ":\n";
                        cin >> waga;
                        lista_krawedzi[i][2]=waga;
                        cout << "\n";
                    };
					
				}	     
          }
 

http://www.cplusplus.com/reference/cstdlib/qsort/

int compare (const void * a, const void * b)
  {
   int **A=(int**)a,**B=(int**)b;
   return ( (*A)[2] - (*B)[2] );
  }
qsort(lista_krawedzi,liczba_krawedzi,sizeof(int*), compare);

Dziękuję bardzo. Działa wyśmienicie.