Sortowanie bąbelkowe listy

Witam!
Mam problem z posortowaniem listy jednokierunkowej bąbelkowo. Za wszelką pomoc z góry dzieki.

#include "stdafx.h"
#include <iostream>
#include <conio.h>
#include <Windows.h>
#include <time.h>

using namespace std;
//----------------------------------------------------------------------
struct ELEMENT                          // struktura elementu roboczego
       {
         int Wartosc;
         struct ELEMENT *Nastepny;      // wskaznik do nastepnego elementu
       };

struct INFO                         // struktura elementu informacyjnego
	{ ELEMENT *Glowa;
	  ELEMENT *Ogon;
	};

//------------------------------------------------------------------------
void Do_Listy( int W, INFO *Wsk);
void Tworz_Liste(int n, INFO *Wsk);
void Pisz_Liste(INFO *Wsk);
void Usun_Liste(INFO *Wsk);
void Pisz_Liste2(INFO *Wsk);
void Sortuj_Babelkowo(INFO *Wsk, int &n);
//------------------------------------------------------------------------
int main ()
{
	srand((unsigned)time(NULL));
  int n;
  INFO *Wsk;                 // wskaznik do elementu informacyjnego
    cout << "Podaj dlugosc listy: ";
    cin >> n;
    Wsk = new INFO;
    Wsk->Glowa = NULL;
    Wsk->Ogon = NULL;
	Tworz_Liste(n, Wsk);
    Pisz_Liste(Wsk);
	Sortuj_Babelkowo(Wsk,n);
	Pisz_Liste(Wsk);
    Usun_Liste(Wsk);
   _getch();
   return 0;
}
//------------------------------------------------------------------------
void Do_Listy(int W, INFO *Wsk)
/* Procedura dolacza nowy element do listy - na koniec listy */
{
  if(W>1 && W<50)
  {
	ELEMENT *Nowy;
	 Nowy = new ELEMENT;
  if (Wsk->Glowa == NULL)     	// dolaczenie nowego elementu
    {                                   // do listy pustej
      Wsk->Glowa = Nowy;
      Wsk->Ogon = Wsk->Glowa;
    }
    else                                // dolaczenie nowego elementu
     { Wsk->Ogon->Nastepny = Nowy; // na koncu listy niepustej
       Wsk->Ogon = Nowy;
     }
   Nowy->Wartosc = W;
   Nowy->Nastepny = NULL;
  }
  
}


void Tworz_Liste(int n, INFO *Wsk)
{
  int i, W=0;
	
	
	for (i=1; i <=n;i++ )
    {
      W=rand()%50 +1;
	  
				 if (W < 1 || W > 50)
                        {
                           do
                           {
                              W=rand()%50 +1;
                           }
                           while (W < 1 || W > 50);
				 }
					Do_Listy(W, Wsk);
                        
      
    
	
	}
}
//------------------------------------------------------------------------
void Pisz_Liste(INFO *Wsk)
/*  Procedura wyswietla elementy listy w kierunku od poczatku do konca */
{
  ELEMENT *Biezacy;
  Biezacy = Wsk->Glowa;
  if (Wsk->Glowa == NULL)
    cout << "\n\nLista jest pusta\n";
    else 
	{
		cout << "\n\nOto lista:\n" << endl;
		while (Biezacy != NULL)
	    {
	      cout << Biezacy->Wartosc << endl;
	      Biezacy = Biezacy->Nastepny;
	     }
    }
}

void Usun_Liste(INFO *Wsk)
{
  ELEMENT *Biezacy, *Usuniety;
  Biezacy = Wsk->Glowa;
  if (Wsk->Glowa == NULL)
    cout << "\n\nLista jest pusta";
    else { while (Biezacy != NULL)
	    {
	      Usuniety = Biezacy;
	      Biezacy = Biezacy->Nastepny;
	      delete Usuniety;
	     }
	     if (Biezacy == NULL)
	       cout << "\nListe usunieto" << endl;
	  }
}
//------------------------------------------------------------------------

void Sortuj_Babelkowo(INFO *Wsk, int &n)

{
	
	ELEMENT *Biezacy, *Przed, *Po;
	





  int i, j,a,b,tmp;
  Biezacy = Wsk->Glowa;
  Po=Biezacy->Nastepny;

  for(j=0; j<n-1;j++)
	 { for (i = 0; i <= n-1; i++)
  {
	  if (Biezacy->Wartosc < Po->Wartosc)
	    { 
			tmp = Biezacy->Wartosc;
	      Po->Wartosc = Biezacy->Wartosc;
	      Po->Wartosc = tmp;
	    }
	 Biezacy = Biezacy->Nastepny;
	 Po = Biezacy->Nastepny;
  }
  Biezacy = Wsk->Glowa;
  Po=Biezacy->Nastepny;

  }
}