Zadanie na listach jednokierunkowych

Witam, mógłby ktoś sprawdzić, i z grubsza obejrzeć ten kod? Niestety nie mam jak sprawdzić czy działa. Chodzi bardziej o koncepcję i algorytm niż o jakieś błędy składniowe.

zadanie jest takie:

Dana jest następująca struktura, definiująca element listy – punkt o współrzędnych
x,
y
:
struct element {
double x, y;
struct element* nast;
};
oraz następująca definicja typu – adresu do elementu listy:
typedef struct element* ADRES;
W programie głównym jest zdefiniowana zmienna pierwszy typu ADRES (która jest adresem
pierwszego elementu istniejącej listy), oraz dodatnia stała
X. Napisz fragment programu, który
podzieli listę na dwie części (listy). W pierwszej z nich mają znaleźć się punkty położone w
odległości nie większej niż
X od środka układu współrzędnych, w drugiej – pozostałe punkty.
Adresy początku nowych list zapamiętaj w zmiennych: p_blizej i p_dalej. Podziału listy na
dwie części dokonaj bez alokowania nowej pamięci. Względna kolejność elementów w obrębie
obu list powinna zostać zachowana.

Mój kod:

#include <stdio.h>
#include <stdlib.h>
#define X 10
#include <math.h>

struct kwadrat{
double x,y;
struct kwadrat *nast;
};
typedef struct kwadrat ELEMENT;
typedef ELEMENT *ADRES;


int main() {
 ADRES pierwszy,zamiana,ostatni;
 ADRES startowy;
 ADRES pom=pierwszy,pom2=pierwszy;

 while(pierwszy!=NULL){
    if((sqrt((pierwszy->nast->x*pierwszy->nast->x)+(pierwszy->nast->y*pierwszy->nast->y)))>X){
        startowy=pierwszy->nast;
        pierwszy->nast=startowy->nast;
        while(pierwszy!=NULL){
            if(pierwszy->nast==NULL){
                pierwszy->nast=startowy;
                startowy->nast=NULL;
                break;
            }
            pierwszy=pierwszy->nast;
        }
        break;
    }pierwszy=pierwszy->nast;
 }
 ostatni=startowy;
 while(pom!=NULL){
        if((sqrt((pom->nast->x*pom->nast->x)+(pom->nast->y*pom->nast->y)))>X){
            if(pom->nast==startowy)break;
            pom->nast=zamiana;
            pom->nast=zamiana->nast;
            zamiana->nast=NULL;
            ostatni->nast=zamiana;
            ostatni=zamiana;
            pom=pom2;
        }

    pom=pom->nast;
 }

 return 0;
}

Komentarz:
Pierwsza pętla while wyszukuje pierwszego elementu listy którego współrzędne są dalej niż X od środka układu, zapisuje go pod zmienną "startowy" oraz przyczepia na koniec listy. Kolejna pętla while leci po całej liście i wyszukuje elementów które spełaniją wymagania(punkty położone dalej niż X) i przerzuca je na koniec listy, za element "startowy". Dzieje się to do tego momenty aż znów natrafimy na element "startowy", wtedy kończymy przeszukiwanie, gdyż za elementem "startowy" są już odpowiednie elementy.

Co o tym myślicie? Dobrze wykonany ten kod?

Co masz na myśli mówiąc:

Niestety nie mam jak sprawdzić czy działa

Jedyne czego to wymaga, to szybka instalacja jakiegoś lekkiego IDE, lub nawet surowego kompilatora gcc i wywołanie go z terminala.

Przechodząc jednak na szybko do Twojego kodu to:
Po pierwsze:

    ADRES pierwszy, zamiana, ostatni;
    ADRES startowy;
    // zmienna  pierwszy  nie jest zainicjalizowana, to się najpewniej nawet nie zbuduje.
    ADRES pom = pierwszy, pom2 = pierwszy;

Po drugie:

while( pierwszy != NULL ){

// To samo tyczy się:
while( pom != NULL ){

Jak chcesz, żeby to zadziałało? Czym ma być zmienna pierwszy aby była różna od NULL i pętla zaczęła się wykonywać?