sortowanie w pliku

ADAM1234 · Post autor: **ADAM1234** » 4 gru 2006, o 14:46

// sortowania na plikach.cpp : main project file.

#include "stdafx.h"
#include <fstream>
#include <iostream>
using namespace System;
using namespace std;

double t[100];

// moje prototypy

int SortowanieWybor(double *);

/************************************************************/
int main()
{
    int k = 0,i = 0, j = 0;
    double rob;
    ifstream pin;
    ofstream din;
    pin.open("liczby.txt");
    din.open("Wynik.txt");
    if (!pin)
    {
      cout << "
BLAD OTWARCIA!
";
      system ("Pause");
      return 1;
    }
	cout <<"Liczby wczytane z pliku: 
";
    while (pin >> rob)
    {
        t[i] = rob;
		i++;
    }
    while(t[j])
    {
        cout <<t[j] <<"
";
        j++;
    }
	cout <<"
Posortowane:

";
    int n = SortowanieWybor(t);
	for(int l = 0; l < n; l++)
	{
        din <<t[k] <<"
";
		cout <<t[k] <<"
";
    }
    //===========================
    din.close();
    pin.close();
    system ("Pause");
    return 0;
}
/************************************************************/
int SortowanieWybor(double *d)
{
    //===========================
    int N = 0, k = 0;
    while(d[k] != NULL)
    {
        N++; k++;
    }
    //===========================
    for(int j = 0; j < N-1; j++)
    {
        int pmin = j;
        for(int i = j+1; i < N-1; i++)
            if(d[i] < d[pmin])
                pmin = i;
        swap(d[j],d[pmin]);
    }
	return N;
}
//////////////////////////////////////////////////////////

powyższy kod wczytuje z jednego pliku liczby double zapisuje je do tablicy po czym w niej sortuje i wynik zapisuje do innego pliku (TAK MIAŁO BYĆ ALE NIE JEST)!!!

b) czy da się sortować w pliku z pominięciem tablicy(pamięci)

proszę o podpowiedzi! Czy mógłby ktoś przytoczyć poprawiony kod

[ Dodano: 4 Grudzień 2006, 19:27 ]
Już MAM:

Kod: Zaznacz cały

// sortowania na plikach.cpp : main project file.

#include "stdafx.h"
#include <fstream>
#include <iostream>
using namespace System;
using namespace std;

double t[1000];

// moje prototypy
void SortowanieSzybkie(int lewy, int prawy);
int SortowanieWybor(double *);
int SortowanieWstawianie(double *);
int SortowanieBabelkowe(double *);

/************************************************************/
int main()
{
    int i = 0, j = 0, n = 0;
    double rob;
    ifstream pin;
    ofstream din;
    pin.open("liczby.txt");
    din.open("Wynik.txt");
    if (!pin)
    {
      cout << "
BLAD OTWARCIA!
";
      system ("Pause");
      return 1;
    }
	cout <<"Liczby wczytane z pliku: 
";
	while (!pin.eof())
    {
		pin >> rob;
        t[i] = rob;
		i++;
    }
    while(i--)
    {
        cout <<t[j] <<"
";
        j++;
    }
	cout <<"
Posortowane:

";din <<"
Posortowane:
";
    // n = SortowanieBabelkowe(t);
    // n = SortowanieWstawianie(t);
    // n = SortowanieWybor(t);
	/***************************************************************/
	// n = j;	SortowanieSzybkie(0,n-1);
	/***************************************************************/
	for(int l = 0; l < n; l++)
	{
        din <<t[l] <<"
";
		cout <<t[l] <<"
";
    }
    //===========================
    din.close();
    pin.close();
    system ("Pause");
    return 0;
}
/************************************************************/
//////////////////////////////////////////////////////////////
int SortowanieWybor(double *d)
{
    //===========================
    int N = 0, k = 0;
    while(d[k] != NULL)
    {
        N++; k++;
    }
    //===========================
    for(int j = 0; j < N; j++)
    {
        int pmin = j;
        for(int i = j+1; i < N; i++)
            if(d[i] < d[pmin])
                pmin = i;
        swap(d[j],d[pmin]);
    }
	return N;
}
//////////////////////////////////////////////////////////
int SortowanieWstawianie(double *d)
{ 
	//===========================
    int N = 0, k = 0;
    while(d[k] != NULL)
    {
        N++; k++;
    }
    //===========================
	for(int j = N - 2; j >= 0; j--)
	{
		double x = d[j];
		int i = j + 1;
		while((i < N) && ( x > d[i]))
		{
			d[i-1] = d[i];
			i++;
		}
		d[i-1] = x;
	}
	return N;
}
////////////////////////////////////////////////////////////
int SortowanieBabelkowe(double *d)
{
	//===========================
    int N = 0, k = 0;
    while(d[k] != NULL)
    {
        N++; k++;
    }
    //===========================
	for(int j = N - 1; j > 0; j--)
		for(int i = 0; i < j; i++)
			if(d[i] > d[i+1])
				swap(d[i],d[i+1]);
	return N;
}
/////////////////////////////////////////////////////////////
void SortowanieSzybkie(int lewy, int prawy)
{
	int i,j;
	double piwot;

	i = (lewy + prawy) / 2;
	piwot = t[i]; t[i] = t[prawy];
	for(j = i = lewy; i < prawy; i++)
	if(t[i] < piwot)
	{
		swap(t[i], t[j]);
		j++;
	}
	t[prawy] = t[j]; t[j] = piwot;
	if(lewy < j - 1)  SortowanieSzybkie(lewy, j-1);
	if(j + 1 < prawy) SortowanieSzybkie(j+1, prawy);
}
///////////////////////////////////////////////////////////////

Intact · Post autor: **Intact** » 11 gru 2006, o 14:32

Da się sortować w pliku tylko to zajmie znacznie więcej czasu.

Ja proponuję wczytać liczbę, sprawdzić czy jest mniejsza od którejkolwiek z już istniejących w tabeli. Niech to majstruje podczas wczytywania.

t - arraya proponowałbym jednak na wskaźnikach bo to ograniczenie jest wkurzające.

Potem niech zapisuje do pliku.

Fibik · Post autor: **Fibik** » 13 gru 2006, o 19:29

Kod: Zaznacz cały

while(d[k] != NULL)
{
   N++; k++;
}

NULL to 0

a co jeśli w tablicy będzie wcześniej 0.0?

int Sortowanie(double d[], int n) // n liczb w t

ADAM1234 · Post autor: **ADAM1234** » 14 gru 2006, o 22:48

Bardziej elegancko jest, jak przesyłam samą tablice (wskaznik)
- a może należało by użyć: '\0'
dokładnie nie wiem, nie pamietam co jest na końcu tablicy zawsze

amdfanatyk · Post autor: **amdfanatyk** » 22 gru 2006, o 23:22

ten program segfolci - przeciez to widac od razu

ADAM1234 · Post autor: **ADAM1234** » 23 gru 2006, o 11:28

ale czemu?

amdfanatyk · Post autor: **amdfanatyk** » 23 gru 2006, o 14:12

bo tablica ma staly rozmiar a wartosc indeksu nie jest kontrolowana.

max · Post autor: **max** » 23 gru 2006, o 15:21

Miała być kontrolowana chyba za pomocą zmiennej N

Kod: Zaznacz cały

	
while(d[k] != NULL)
{
   N++; k++;
}

Tyle, że to nie powinno się udać, bo wartością NULL (0 czy też '\0') to kończą się tylko łańcuchy char* a nie wszystkie tablice.