Zawieszanie się programy z macierzami oraz dziwne wartości

Witam, mam problem z programami w obydwóch chodzi prawie o to samo. Mam wyznaczyć macierze schodkowe w programie Interpolacja Lagrange oraz w programie Eliminacji Gaussa.

W Lagrange: wszystko działa ładnie dla macierzy maks 5x5 w przypadku 6x6 i wyższych program sie zawiesza.
W Metodzie Eliminacji Gaussa: działa dla dużych wartości ale wyświetla czasami a nawet dość często wartości ,,-0" w macierzy schodkowej która jest wyzerowana.

Nie chce gotowego kodu żeby wkleić tylko jakąś podpowiedź albo nakierowanie na to bym znalazł problem.

ELIMINACJA GAUSSA:

#include <iostream>

using namespace std;
class EG
{
private:
    int rozmiar;
    long double **macierz;
public:
    void wprowadzanie()
    {
        cin>>rozmiar;
        macierz=new long double*[rozmiar];
        for(int i=0;i<rozmiar+1;i++)
            macierz[i]=new long double[rozmiar+1];
        for(int i=0;i<rozmiar;i++)
            for(int j=0;j<rozmiar+1;j++)
                cin>>macierz[i][j];

    }
    void drukuj()
    {
        cout.precision(4);
        for(int i=0;i<rozmiar;i++)
        {
            for(int j=0;j<rozmiar+1;j++)
                cout<<macierz[i][j]<<"\t";
            cout<<endl;
        }
    }
    //zamienia miejscami wiersze w wskazanym wierszu
    void element_max(int nr_wier)
    {
            int nr_kol=nr_wier;
            int maks=macierz[nr_wier][nr_kol];
            int wiersz_z_maks=nr_wier;
            for(int j=nr_wier+1;j<rozmiar;j++)
                if(macierz[j][nr_kol]>maks)
                {
                    maks=macierz[j][nr_kol];
                    wiersz_z_maks=j;
                }
            for(int i=nr_wier;i<rozmiar;i++)
            {
                float tmp;
                tmp=macierz[nr_wier][i];
                macierz[nr_wier][i]=macierz[wiersz_z_maks][i];
                macierz[wiersz_z_maks][i]=tmp;
            }

    }
    void wyzn_mac_schodkowej()
    {


            int a=1,b=0,c;// zmienne pomocnicze
            long double wsp;


            element_max(0);
            //wyznaczenie ,,1" w pierwszym wierszu a00
            float dzielnik=macierz[0][0];
            for(int i=0;i<=rozmiar;i++)
                macierz[0][i]=macierz[0][i]/dzielnik;


            while(a<rozmiar)
            {
                c=a;
                element_max(a);

                for(int i=a;i<rozmiar;i++)
                {

                    wsp=(macierz[c][b]/macierz[b][b]);          //wyznaczanie wspolczynnika
                    //zerowanie elementow w kolumniie
                    for(int j=b;j<=rozmiar;j++)
                    {
                       macierz[i][j]=macierz[i][j]-(wsp*macierz[a-1][j]);
                    }
                    //wyznaczanie "1" na przekatnej
                    dzielnik=macierz[i][i];
                    for(int k=0;k<=rozmiar;k++)
                        macierz[i][k]=macierz[i][k]/dzielnik;
                    c++;
                }
                a++;
                b++;
            }

    }
};
int main()
{
    EG obiekt1;
    obiekt1.wprowadzanie();
    obiekt1.drukuj();
    obiekt1.wyzn_mac_schodkowej();
    obiekt1.drukuj();
    return 0;
}
 

INTERPOLACJA LAGRANGE

 #include <iostream>
#include <math.h>
using namespace std;
class lagrange
{
    float *tabX;
    float *tabY;
    long double **macierzA;
    int rozmiar;
public:
    void wprowadzanie()
    {

        cin>>rozmiar;
        tabX=new float [rozmiar];
        tabY=new float [rozmiar];
        for(int i=0;i<rozmiar;i++)
        {
            cin>>tabX[i];
            cin>>tabY[i];
        }
    }
    void tworzenie_macierzA()
    {
        macierzA=new long double *[rozmiar];
        for(int i=0;i<rozmiar;i++)
            macierzA[i]=new long double [rozmiar];
        for(int i=0;i<rozmiar;i++)
            for(int j=0;j<rozmiar;j++)
                macierzA[i][j]=pow(tabX[i],j);
    }
    void wyzn_mac_schodkowej()
    {


            int a=1,b=0,c;// zmienne pomocnicze
            long double wsp;
            while(a<rozmiar)
            {
                c=a;
                for(int i=a;i<rozmiar;i++)
                {
                    wsp=(macierzA[c][b]/macierzA[b][b]);          //wyznaczanie wspolczynnika
                    //zerowanie elementow w kolumniie
                    for(int j=b;j<=rozmiar;j++)
                    {
                       macierzA[i][j]=macierzA[i][j]-(wsp*macierzA[a-1][j]);
                    }
                    c++;
                }
                a++;
                b++;
            }

    }

    void wyswietl()
    {
        for(int i=0;i<rozmiar;i++)
        {
            for(int j=0;j<rozmiar;j++)
                cout<<macierzA[i][j]<<"\t";
            cout<<"\n";
        }
    }
};
int main()
{
    lagrange obiekt1;
    obiekt1.wprowadzanie();
    obiekt1.tworzenie_macierzA();
    obiekt1.wyswietl();
    obiekt1.wyzn_mac_schodkowej();
    obiekt1.wyswietl();

    return 0;
}

Jak w przypadku Lagrange'a ma się rozmiar do ilości podawanych danych?

na wejsciu podaje rozmiar( ilosc par parametrow x i y) pozniej macierzA uzupelniam na podstawie tabX gdzie pierwsza kolumna to tabX[i] podnoszona do kolejnych poteg gdzie najwieksza potega to rozmiar-1. drugi wiersz drugi element tabX

Zarówno w pierwszym jak i w drugim może Ci się zdarzyć dzielenie przez 0.

Dzięki wielkie zapomniałem o tym warunku ;)

niestety nic nie zdziałałem. Siedze cała noc a to dalej nie działa tak jak powinno. Metoda Gaussa z pełnym wyborem elementu maksymalnego. Gdyby ktos mógł powiedziec gdzie lezy bład bo za 4 godziny musze to skonczyc bo do oddania na zaliczenie to będe bardzo wdzięczny

 #include <iostream>
#include <cmath>
#include <iomanip>

using namespace std;
class metoda_eliminacji_gaussa
{
private:
    double **macierz;
    int rozmiar;
public:
    void wczytywanie_macierzy()
    {
        cout<<"Podaj rozmiar macierzy a nastepnie wprowadz kolejno elementy macierzyX(wspolczynniki przy x)\n";
        cout<<"macierzyX(wspolczynniki przy x) po kazdym wprowadzonym elemencie wcisnij ENTER \n";
        cout<<"Podaj rozmiar: ";
        cin>>rozmiar;
        cout<<"A teraz wprowadzaj kolejno elementy\n";
        macierz=new double *[rozmiar];
        for(int i=0;i<rozmiar+1;i++)
            macierz[i]=new double [rozmiar+1];
        for(int i=0;i<rozmiar;i++)
            for(int j=0;j<rozmiar;j++)
                cin>>macierz[i][j];
        cout<<"Podaj kolejne wartosci Y\n";
        for(int i=0;i<rozmiar;i++)
            cin>>macierz[i][rozmiar];

    }
    void drukuj_macierz()
    {
        for(int i=0;i<rozmiar;i++)
        {
            for(int j=0;j<rozmiar+1;j++)
                cout<<setw(4)<<macierz[i][j]<<"\t";
            cout<<endl;
        }
    }
    void zamiana_wierszy(int nr_wiersza_na_ktorym_pracujemy, int nr_wiersza_ktory_zamienimy)
    {
        double zmienna_pomocnicza;
        for(int j=0;j<rozmiar+1;j++)
        {
            zmienna_pomocnicza=macierz[nr_wiersza_na_ktorym_pracujemy][j];
            macierz[nr_wiersza_na_ktorym_pracujemy][j]=macierz[nr_wiersza_ktory_zamienimy][j];
            macierz[nr_wiersza_ktory_zamienimy][j]=zmienna_pomocnicza;

        }
    }
    void zamiana_kolumny(int nr_kolumny_na_ktorej_pracujemy, int nr_kolumny_ktora_zamienimy)
    {
        double zmienna_pomocnicza;
        for(int i=0;i<rozmiar;i++)
        {
            zmienna_pomocnicza=macierz[i][nr_kolumny_na_ktorej_pracujemy];
            macierz[i][nr_kolumny_na_ktorej_pracujemy]=macierz[i][nr_kolumny_ktora_zamienimy];
            macierz[i][nr_kolumny_ktora_zamienimy]=zmienna_pomocnicza;

        }
    }
    void element_max(int nr_wiersza,int nr_kolumny)
    {
        double el_max=macierz[nr_wiersza][nr_kolumny];
        int max_i=nr_wiersza;
        int max_j=nr_kolumny;
        for(int i=nr_wiersza;i<rozmiar;i++)
            for(int j=nr_kolumny;j<rozmiar;j++)
            {
                if(macierz[i][j]>el_max)
                {
                    el_max=macierz[i][j];
                    max_i=i;
                    max_j=j;
                }
            }
        zamiana_wierszy(nr_wiersza,max_i);
        zamiana_kolumny(nr_kolumny,max_j);
    }
     bool wyzn_mac_schodkowej()
    {
        int tmp=0;
        double wsp;
        while(tmp<rozmiar-1)
        {
            element_max(tmp,tmp);
            if(macierz[tmp][tmp]==0)
            {
                return false;
            }
            else
            {
                for(int i=tmp+1;i<rozmiar;i++)
                {
                    wsp=macierz[i][tmp]/macierz[tmp][tmp];
                    cout<<wsp<<endl;
                    for(int j=tmp;j<rozmiar+1;j++)
                    {
                        macierz[i][j]=macierz[i][j]-wsp*macierz[tmp][j];
                    }
                    drukuj_macierz();
                    cout<<endl;
                }
            }
            tmp++;
        }
        return true;
}
};
int main()
{
    cout << setprecision(4) << fixed;
    metoda_eliminacji_gaussa obiekt;
    obiekt.wczytywanie_macierzy();
    obiekt.drukuj_macierz();

    obiekt.wyzn_mac_schodkowej();
    if(obiekt.wyzn_mac_schodkowej()==false)
        cout<<"macierz nie posiada tylko jednego rozwiazania"<<endl;
        else
            obiekt.drukuj_macierz();
    cout << "Hello world!" << endl;
    return 0;
}

potrzebuje przy pomocy przy lagrang'u zawiesza sie np czy wartsciach X{1,3,5,7,9} Y{2,4,6,8,10} cwiczeniowca ma w dupie studentow i pajacuje jak prosi sie o pomoc wiec nic innego mi nie pozostaje jak was prosic o rade( dzielenie przez zero uwzglednilem)