C++: Insertion Sort nie działa dla losowych wartości w tablicy tau_1

 void insertion_sort(double x[],int length)  //sortowanie przez wstawianie 
{
  int i,j;
  double temp;
  for(j=1;j<length;j++)
  {
     temp=x[j];
     i=j-1;
     while(x[i]>temp && i>=0)
     {
               x[i+1]=x[i];
         i--;
     }
     x[i+1]=temp;
  }
}
//-----------------------
srand(time(NULL));

double uni_dyst;
uni_dyst=(double)rand()/RAND_MAX;
if (uni_dyst==0)uni_dyst=0.0000000001 ;

double tau_1[6];
int k;
        for (k=0;k<6;k++)
        {
        tau_1[k]=-r_DS_SMa*sigma_DS(epsilon_DS_SMa,mikro_DS_SMa)*log(uni_dyst);
        StringGrid1->Cells[k+1][2]=AnsiString(tau_1[k]);
        }

insertion_sort(tau_1,6);

#include <iostream>
#include<conio.h>
#define elementy 6

using namespace std;

void jakies_sortowanie(int x[],int length)
{
  int kk,i;
  for(int j=1;j<length;j++)
  {
     kk=x[j];
     i=j-1;
     while(x[i]>kk && i>=0)
     {
               x[i+1]=x[i];
         i--;
     }
     x[i+1]=kk;
  }
}

int main()
{
cout << "--------------------------\n"
     << "Sorowanie przez wstawianie\n"
	 << "--------------------------\n\n\n";
  int A[elementy]={8,5,3,1,9,11};
  int x;

  cout<<"Nieposorotwana lista\n";
  for(x=0;x<elementy;x++)
  {
       cout<<A[x]<<endl;
  }
  jakies_sortowanie(A,elementy);
  cout<<"\n\nPosortowana lista wyglada tak ooo: \n\n";
  for(x=0;x<elementy;x++)
  {
       cout<<A[x]<<endl;
  }
  getch();
  getch();
  return 0;
}

# include <iostream>
# include <conio.h>

using namespace std;

void sort_jakis_tam(int tab[], int n);


    main(){
    int tab[20];
    int n;
    cout<<"Ile liczb bedziemy sortowac: \n\n";
    cin>>n;


        for(int i=0;i<n;i++){
        cout<<"Dajesz liczby " << i + 1  << " i naciskaj ENTER\n";
        cin>>tab[i];
    }

    sort_jakis_tam(tab, n);
}

void sort_jakis_tam(int tab[], int n)


    {
    	int a[30];
    	a[0] = tab[0];
    	for (int i = 1; i < n; i++)


        	{
        		int temp = tab[i];
        		int j = i - 1;
        		while (( a[j] > temp) && (j>=0))


            		{
            			a[j+1] = a[j];
            			j--;
            		}
            		a[j+1] = temp;
            	}
            	for (int k = 0; k < n; k++)


                	{
                		tab[k] = a[k];
            }

            cout<<"Nacisnij ENTER aby zobaczyc posortowane liczby\n\n";


                for(int x=0;x<n;x++){
                cout<<"Posortowana liczba " << x + 1 << " to: "<<tab[x]<< "\n";
                getch();
                
                
            }

        }

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "fMIMO_Channel_1.h"

#include <alloc.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define PI 3.141592654
#define r_DS_SMa 1.4
#define epsilon_DS_SMa 0.288
#define mikro_DS_SMa -6.80


double gngauss(double mean, double sigma) {    // zmienna o rozkladzie normalnym (Gaussowskim)

    double u, r;
    u = (double)rand() / RAND_MAX;
    if (u == 1.0) u = 0.999999999;

    r = sigma * sqrt( 2.0 * log( 1.0 / (1.0 - u) ) );

    u = (double)rand() / RAND_MAX;
    if (u == 1.0) u = 0.999999999;

    return( (double) ( mean + r * cos(2 * PI * u) ) );
}
//////////////////////////////////////////////////////////////////////////////////////
double sigma_DS(double epsilon_DS, double mikro_DS){

        return((double)(pow(10,epsilon_DS * gngauss(0,1)+ mikro_DS)));
}
//////////////////////////////////////////////////////////////////////////////////////

void insertion_sort(double *x, int length)
{
 for(int j=1; j<length ;++j)        //od drugiego elementu do ostatniego
  {
   double temp = x[j];             //zapamietaj wartość elementu
   int i=j-1;                        //indeks poprzednika
   while((i>=0) && (x[i]>temp)) //dopóki istnieje poprzednik
    {                                //i jego wartość jest większa
     x[i+1] = x[i];      //przesuń poprzedni element w prawo
     --i;
    }
   x[i+1] = temp;               //wstaw i-ty element w odpowiednim miejscu
  }
}
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{

int i;
         for (i=1; i < 7; i++)
        {
          StringGrid1->Cells[i][1]="N/A";
          StringGrid1->Cells[i][2]="N/A";
        }
       StringGrid1->Cells[0][1]="Moc";  
       StringGrid1->Cells[0][2]="Opoz";
       StringGrid1->Cells[0][3]="Opoz sort";
       StringGrid1->Cells[0][4]="Opoz wzgl";
       StringGrid1->Cells[1][0]="N_1";
       StringGrid1->Cells[2][0]="N_2";
       StringGrid1->Cells[3][0]="N_3";
       StringGrid1->Cells[4][0]="N_4";
       StringGrid1->Cells[5][0]="N_5";
       StringGrid1->Cells[6][0]="N_6";
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
srand(time(NULL));

double uni_dyst;                      // zmienna o rozkladzie rownomiernym  w <0,1>
uni_dyst=(double)rand()/RAND_MAX;
if (uni_dyst==0)uni_dyst=0.0000000001 ;

double tau_1[6];
int k;
        for (k=0;k<6;k++)
        {
        tau_1[k]=-r_DS_SMa*sigma_DS(epsilon_DS_SMa,mikro_DS_SMa)*log(uni_dyst);
        StringGrid1->Cells[k+1][2]=AnsiString(tau_1[k]);
        }
try
{
insertion_sort(tau_1,6);
}
catch(...)
{
}
int l;
        for (l=0;l<6;l++)
        {
        StringGrid1->Cells[l+1][3]=AnsiString(tau_1[l]);
        }
}

//---------------------------------------------------------------------------