Zmiana domyślnego sortowania na bardziej szczegółowy

Cześć,
muszę posortować koordynacje (x,y,z).
Mam zrobione sortowanie, że porównuję x do x, ale muszę zrobić tak, żeby sortowało po x, ale jak są równe to przechodzi do y.

class Program
    {
        static void Main(string[] args)
        {
            //int space;
            int t = int.Parse(Console.ReadLine());
            List<Wspolrzedne> list = new List<Wspolrzedne>();
            for (int i = 0; i < t; i++)
            {
                string[] tab = Console.ReadLine().Split(' ');
                Wspolrzedne wspolrzedne = new Wspolrzedne(int.Parse(tab[0]), int.Parse(tab[1]), int.Parse(tab[2]));
                list.Add(wspolrzedne);
            }

            list.Sort();
            list.ForEach(wspolrzedne => Console.WriteLine("{0} {1} {2}", wspolrzedne.X,wspolrzedne.Y, wspolrzedne.Z));
           
            
            Console.ReadKey();

        }


        public class Wspolrzedne
        {
            public int X { get; set; }
            public int Y { get; set; }
            public int Z { get; set; }
            public Wspolrzedne(int x, int y, int z)
            {
                X = x;
                Y = y;
                Z = z;
            }

            public int CompareTo(Wspolrzedne other)
            {
                return X.CompareTo(other.X);
            }
        }

Nie wiem jak wrzucić sortowanie bąbelkowe do środka. Mam coś takiego:

var array = list.ToArray();

            for (int i = 0; i < array.Length; i++)
            {
                for (int j = 0; j < array.Length - 1; j++)
                {
                    if (array[j] > array[j + 1])
                    {
                        space = array[j + 1];
                        array[j + 1] = array[j];
                        array[j] = space;
                    }
                }
            }

Czy wrzucać listę do tablicy? Czy moglibyście delikatnie nakierować, czy to w ogóle idzie w dobrą stronę? Czy wybrać inne sortowanie do tego(np. przez wybieranie)?

A jak y równe, to porównujemy z, a gdy z równe, to współrzędne równe? To napisz taką funkcję porównującą i uzyj jej, jako porównanie, w metodzie sortującej tablicę obiektów, Wspolrzedne.

No i czy musi być bąbelkowe?

O to chodziło? :

   static void Main(string[] args)
        {
            int t = int.Parse(Console.ReadLine());
            List<Wspolrzedne> list = new List<Wspolrzedne>();
            for (int i = 0; i < t; i++)
            {
                string[] tab = Console.ReadLine().Split(' ');
                Wspolrzedne wspolrzedne = new Wspolrzedne(int.Parse(tab[0]), int.Parse(tab[1]), int.Parse(tab[2]));
                list.Add(wspolrzedne);
            }
            list.Sort();
            list.ForEach(wspolrzedne => Console.WriteLine("{0} {1} {2}", wspolrzedne.X, wspolrzedne.Y, wspolrzedne.Z));

            Console.ReadKey();
        }

        public class Wspolrzedne : IComparable<Wspolrzedne>
        {
            public int X { get; set; }
            public int Y { get; set; }
            public int Z { get; set; }
            public Wspolrzedne(int x, int y, int z)
            {
                X = x;
                Y = y;
                Z = z;
            }

            public int CompareTo(Wspolrzedne other)
            {
                if (this.X != other.X)
                    return this.X.CompareTo(other.X);

                if (this.Y != other.Y)
                    return this.Y.CompareTo(other.Y);

                return this.Z.CompareTo(other.Z);
            }
        }
    }

@mariano901229:
To ma sens, działa.
Próbowałem wcześniej czegoś takiego i zrezygnowałem(fail).

if (X == X)
               {
                   if (Y == Y) return Z.CompareTo(other.Z);
                   return Y.CompareTo(other.Y);

               }
               else return X.CompareTo(other.X);

Dzięki bardzo

Tak tak, wybacz. Właśnie próbuję to jakoś wpisać do Wspolrzedne, ale za każdym razem jest jakiś błąd typu, że nazwa nie istnieje w bieżącym kontekście. Dlatego myślałem, żeby sortowanie wstawić do głównej funkcji, tyle że mam bład Błąd CS0019 Nie można zastosować operatora „>” do argumentów operacji typu „Program.Wspolrzedne” lub „Program.Wspolrzedne”. ZadankaAlgorytmy D:\Algorytmy\ZadankaAlgorytmy\ZadankaAlgorytmy\Program.cs — monki 23 minuty temu

Nie musi, tylko wydaję mi się, że będzie najprostsze do wykonania. Myślałem jeszcze nad sortowaniem przez wybieranie(wydaje mi się, że potrzebuje więcej czasu od bąbelkowego) i nad szybkim sortowaniem(ten akurat wydaję mi się trochę za skomplikowany póki co) — monki 24 minuty temu

Miotasz się.
Przemieszczenia kodu i błędy kompilacji to jedno.
Zasada porównania to drugie
nadrzędny algorytm sortowania (bubble, qsort itp) to trzecie

Musisz nauczyć się rozdzielać problemy na podproblemy i je sukcesywnie rozwiązywać. Analiza i kodowanie "na kupę" jest najgorszym ze sposobów
edit: tu jest jeszcze najgorszy odcień miotania się. z niezałatwionym problemem "jak porównywać" skaczesz do np "zmiany algorytmu sortującego" ... bo co, bo pierwszy niezałatwiony problem sam się naprawi? Nie naprawi się.

Na marginesie: Po co jest ten algorytm? Mi się wydaje, że jak do gry, czy czegoś podobnego to tzreba poszukać jakiejś uznanej miary sortowania w 3ch wymiarach

Dla quick sort zamiast funkcji zwracającej bool (czyli większe albo nie) potrzebujesz funkcji zwracającej jedną z trzech wartości: mniejsze, równe i większe, czyli np.: -1, 0 i 1.