Segregowanie tablicy.

#include <iostream>

using namespace std;
const int n = 5;

void wprowadzliczby(int tab[n])
{
	for(int i = 0;i<n;i++)
	{
		tab[i]=rand()%50;
	}
}
void wypisz(int tab[n])
{
	for(int i=0;i<n;i++)
	{
		cout << tab[i] <<endl;
	}
}
void wartoscm(int tab[n])
{
	int min = tab[0];
	for(int i=1;i<n;i++)
	{		
		if(tab[i]<min)min = tab[i] ??;
	}
	????
}

int main()
{
int tab[n];

wprowadzliczby(tab);
wypisz(tab);
wartoscm(tab);
getchar();
getchar();
return 0;
}

Próbuje napisać program który segreguje tablice i chciałbym żeby mi ktoś mi wytłumaczył co mam zrobić po tym gdy sprawdzę czy wartość tablicy dla elementu i jest mniejsze od wartosci min

Segreguje w jaki sposób? od najmniejszej wartości? od największej? poza tym zależy od algorytmu jakiego chcesz użyć, możesz np przesuwać liczby w tej tablicy żeby zrobić na początku miejsce dla najmniejszego, potem dla najmniejszego bez tego co go już przeniosłeś itd. Albo też iść od początku, i jeśli element jest mniejszy od poprzedniego, to wtedy wstawiasz go wcześniej tam gdzie ma być (znowu przesuwając odpowiednio tablice. Jak przesuwać tablicę? zapisujesz tego minimuma do jakiejś zmiennego, potem w pętli "w dół" za element tab[i] podstaw tab[i-1], i tak aż dojdziesz do miejsca gdzie ta liczba ma być, i tam go wstawiasz z tej zmiennej.

ps to tylko ogólna koncepcja, nie sprawdzałem. Poza tym są różne algorytmy sortowania.

Jeżeli chcesz znaleźć minimalną wartość w tablicy i później coś z nią zrobić, to możesz stworzyć dwie tablice o tej samej wielkości. Jedną nieposortowaną, a drugą docelowo posortowaną. Po odnalezieniu w tablicy nieposortowanej najmniejszej wartości, zapisujesz ją do pierwszego elementu w tablicy docelowo posortowanej. Elementowi źródłowemu w tablicy nieposortowanej, z ową minimalną wartością, przypisujesz maksymalną wartość, jaką można wyrazić przy pomocy zmiennej typu int. Dzięki temu przy lokalizowaniu kolejnej najmniejszej wartości, ostatnio wyszukany element nie zostanie uwzględniony.

Poniżej przykład:

#include <iostream>
#include <time.h>


const unsigned int g_uSize = 10;

const unsigned int g_uMaxShow = 20;


void FillRandomly(int* aiTab)
{
	for (unsigned int u = 0; u < g_uSize; u++)
	{
		aiTab[u] = (rand() % 50);
	}
}


void Show(int* aiTab)
{
	if (g_uSize > g_uMaxShow)
	{
		for (unsigned int u = 0; u < g_uMaxShow; u++)
		{
			std::cout << "aiTab[" << u << "] = " << aiTab[u] << "\n";
		}

		std::cout << ".\n.\n.\n";
	}
	else
	{
		for (unsigned int u = 0; u < g_uSize; u++)
		{
			std::cout << "aiTab[" << u << "] = " << aiTab[u] << "\n";
		}
	}

	std::cout << "\n";
}


int GetNextMin(int* aiTab)
{
	if (g_uSize > 0)
	{
		unsigned int uMinPos = 0;

		for (unsigned int u = 1; u < g_uSize; u++)
		{
			if (aiTab[u] < aiTab[uMinPos])
			{
				uMinPos = u;
			}
		}

		int iMin = aiTab[uMinPos];

		aiTab[uMinPos] = INT_MAX;

		return iMin;
	}

	return 0;
}


void Sort(int* aiResult, int* aiTabToSort)
{
	for (unsigned int u = 0; u < g_uSize; u++)
	{
		aiResult[u] = GetNextMin(aiTabToSort);
	}
}


int main(int argc, char** argv)
{
	srand(time(NULL));

	int aiTabToSort[g_uSize];
	int aiResult[g_uSize];

	FillRandomly(aiTabToSort);

	std::cout << "Before sort:\n";
	Show(aiTabToSort);

	Sort(aiResult, aiTabToSort);

	std::cout << "After sort:\n";
	Show(aiResult);

	system("PAUSE");
	return 0;
}

Problem w tym, że złożoność obliczeniowa będzie znaczna. Dochodzi jeszcze podwojenie obszaru pamięci. :D Na Twoim miejscu spróbowałbym zaimplementować chociażby sortowanie bąbelkowe. ;)

#include <iostream>

using namespace std;

void losuj(int tab[],int rozmiar)
{
	for(int i=0;i<rozmiar;i++)
	{
		tab[i]=rand()%35;
		cout << "Element "<<i <<" tablicy ma wartosc"<<tab[i]<<endl;
	}
}

void sortuj(int tab[],int rozmiar)
{
	for(int i = 1;i<rozmiar;i++)
	{
		if(tab[i]<tab[i-1])
		{
			int temp = tab[i];
			tab[i] = tab[i-1];
			tab[i-1]=temp;

		}
	}
}

int main()
{
int rozmiar = rand()%15;
int tab[100];
losuj(tab,rozmiar);
sortuj(tab,rozmiar);
for(int i=0;i<rozmiar;i++)
{
		cout << "Element "<<i <<" tablicy ma wartosc"<<tab[i]<<endl;
}

getchar();
getchar();
return 0;
}

spróbowałem to napisać z sortowanie bąbelkowym ale gdzieś coś zrobiłem źle. Kto pomoże mi znaleźć błąd oraz pokazać mi inne błędy jakie zrobiłem w tym programie

Problem tkwi w funkcji sortującej. Tablica jest "przeglądana" zaledwie jednokrotnie, co nie gwarantuje uzyskania posortowanej tablicy. Czynność należy powtarzać do momentu, w którym okaże się, że wszystkie wartości są już na swoich miejscach. Można to osiągnąć poprzez użycie "flagi" - np. zmiennej typu bool.

Przykładowa funkcja nawiązująca do mojego poprzedniego kodu:

void BubbleSort(int* aiTab)
{
	bool bMod = true;

	while (bMod == true)
	{
		bMod = false;

		for (unsigned int u = 1; u < g_uSize; u++)
		{
			// Porównanie dwóch sąsiadujących ze sobą elementów.
			if (aiTab[u - 1] > aiTab[u])
			{
				// Zamiana miejscami w przypadku, gdy element okazał się większy od następnika.
				int iTemp = aiTab[u];
				aiTab[u] = aiTab[u - 1];
				aiTab[u - 1] = iTemp;

				// Zaszła co najmniej jedna modyfikacja w tablicy.
				bMod = true;
			}
		}
	}
}

@_FURYAN_, polecam takie podejście. Pętla "zgarnia" największy element i jeżeli ostatnia wymiana w pętli była tb[p-1]<->tb[p] to znaczy że następny obrót pętli wystarczy skończyć na p-1, ponieważ od p do końca już są posortowane największe

void BubbleSort(int *tb,unsigned size)
  {
   for(unsigned max=size,used=0;max;max=used,used=0)
     {
      for(unsigned p=1;p<max;++p)
        {
         if(tb[p-1]>tb[p])
           {
            int tmp=tb[p-1];
            tb[p-1]=tb[p];
            tb[p]=tmp;
            used=p;
           }
        }
     }
  }

Ba i kod staje się trochę prostszy.

Algorytmów sortowania jest sporo. Dobierasz algorytm przede wszystkim do danych wejściowych(czy będzie ich dużo czy mało), czy tablica będzie już częściowo posortowana, czy zależy Ci na czasie...
W swoim przykładzie podałeś 5 elementów więc proponuje zwykłe sortowanie przez wstawianie. Jednak jeżeli danych będzie dużo więcej np 50 000 to proponuję bardziej skomplikowany algorytm(do napisania) np quicksort, quicksort połączony ze wstawianiem lub przez kopcowanie. Quicksort mniej więcej powinien wyglądać tak:

int szuksrod(int d, int g, int t[]) {
int granica = t[d];
int srodek = d;
for (int i=d+1; i<=g; i++) {
if (t[i] < granica) {
srodek=srodek+1;
int tmp = t[srodek];
t[srodek] = t[i];
t[i] = tmp;
}
}
int tmp = t[srodek];
t[srodek] = t[d];
t[d] = tmp;

 return srodek;

}

void qsort(int d, int g, int t[]) {
int s;
if (d<g) {
s = szuksrod(d,g,t);
qsort(d, s-1, t);
qsort(s+1, g, t);
}
}

Informacje: http://pl.wikipedia.org/wiki/Sortowanie_b%C4%85belkowe
Więcej informacji: http://pl.wikipedia.org/wiki/Sortowanie_grzebieniowe
Więcej informacji: http://pl.wikipedia.org/wiki/Sortowanie_koktajlowe
Więcej informacji: http://pl.wikipedia.org/wiki/Sortowanie_przez_wstawianie
Więcej informacji: http://pl.wikipedia.org/wiki/Sortowanie_przez_wybieranie
Więcej informacji: http://pl.wikipedia.org/wiki/Sortowanie_szybkie

Przejrzyj to.