C

[Gtx OP]

Potrzebuje programu w c, a dokładnie tak aby sortowało bąbelkowo... niby wszystko mam ok, ale koszt tych "przesunięć" się nie zgadza, bo powinno wynosić 12 a daje wynik 5 :/
Ktoś pomoże?

#include <stdlib.h>
#include <stdio.h>
int main(){
int tab[4]= {3,1,2,4},j,i,x,c,k;
int a=4;

for(c=0; c<a; c++){
printf("%4d",tab[c] );
}

 for(j=0; j<a; j++)
 for(i=0; i<a; i++)
 if(tab[i] > tab[i+1]){
 x = tab[i];
 tab[i] = tab[i+1];
 tab[i+1] = x;
 k =tab[i]+tab[i+1];

 }
printf("\n" );
for(c=0; c<a; c++){
printf("%4d",tab[c] );
}
printf("\nKoszt: %d\n", k);



system("pause");
return 0;
}

[alien]

Co ten koszt ma symbolizować? Bo w tym kodzie do zmiennej k jest zapisywana w każdej iteracji suma wartości zamienionych elementów, więc na końcu programu przyjmuje on taka wartość jak ostatnie dwa zamienione elementy dodane do siebie, w tym przypadku 3+2

Tam powinno być chyba k = k + 1 (nie znam składni C), a podczas definiowania int k = 0, jeśli koszt to ilość zmian kolejności elementów

[Chels]

ten program dodaje ci wartosc spod tab[i] i tab[i+1]
jezeli chcesz liczyc kroki to musi byc k=k+1
no i wypadalo by wyzerowac zmienna k zanim ja uzyjesz

[Gtx OP]

Dobra, dzięki chłopaki już i tak za późno :)

A jakby komuś się przydało to łapcie

//‪#‎include‬ <scoped_allocator>

// 3 4 2 1
// 3 1 2 4 5
// 3 2 1 4 3
// 1 2 3 4 4

//3 2 1

//8 4 1 2
int* posortowana_tablica;
int posortowana_tablica_rozmiar;
void Posortuj(int *tablica, int rozmiar)
{
posortowana_tablica_rozmiar = rozmiar;
posortowana_tablica = (int*)malloc(sizeof(int)*rozmiar);
int i;
for(i=0;i<rozmiar;i++)
{
posortowana_tablica[i] = tablica[i];
}

int n = rozmiar;
do
{
for (i = 0; i < n-1; i++)
{
if( posortowana_tablica[i] > posortowana_tablica[i+1] )
{
int pom = posortowana_tablica[i];
posortowana_tablica[i] = posortowana_tablica[i+1];
posortowana_tablica[i+1] = pom;
}
}
n--;
}while( n > 1);
}
// zwraca pozycję dla danej liczby w posortowanym ciągu
int WezPozycje(int liczba)
{
int i;
for(i=0;i<posortowana_tablica_rozmiar;i++)
{
if(posortowana_tablica[i] == liczba)
return i;
}
return 0;
}

// zwraca liczbę dla danej pozycji w posortowanym ciągu
int WezElement(int pozycja)
{
if(pozycja >= posortowana_tablica_rozmiar)
return 0;
return posortowana_tablica[pozycja];
}

// Wypisuje Wszystkie elementy w tablicy w aktualnej kolejności
void WypiszTablice( int* tablica, int rozmiar )
{
int j;
printf("Tablica: ");
for(j=0;j<rozmiar;j++)
printf("%d ", tablica[j]);
printf("\n");
}
// Sprawdzenie, czy sortowanie jest skończone
int PorownajTablice(int* tablica1, int* tablica2, int rozmiar)
{
int i;
for(i=0;i<rozmiar;i++)
{
if(tablica1[i]!=tablica2[i])
return 1;
}
return 0;
}

int main()
{
// Przykładowe ciągi
//int tablica[] = { 3, 2, 1 };
int tablica[] = { 8, 4, 1, 2 };
//int tablica[4] = { 3, 4, 2, 1 };
//int tablica[] = { 8, 5, 2, 1 };
//int tablica[4] = { 1, 4, 2, 3 };

// Tworzenie Posortowanej tablicy
Posortuj(tablica, sizeof(tablica)/sizeof(int));

int pozycja = 0;
int najm_el = -1;
int koszt = 0;
int i = 0;
int j;

// Sprytne Liczby - liczby, które są na odpowiadających sobie polach i można je ze sobą odrazu zamienić.
printf("Sprytne liczby - BEGIN\n");
for(i=0;i<posortowana_tablica_rozmiar;i++)
{
if(WezPozycje(tablica[i]) != i)
{
//int element = tablica[i];
int poz = WezPozycje(tablica[i]);
if(tablica[poz] == WezElement(i))
{
int pom = tablica[poz];
tablica[poz] = tablica[i];
tablica[i] = pom;
koszt += tablica[i]+tablica[poz];
// Wypisujemy początkowy stan tablicy
WypiszTablice(tablica, sizeof(tablica)/sizeof(int));
printf("\b koszt:%d\n\n", koszt);
}
}
}
printf("Sprytne liczby - END\n");

printf("Sortowanie najmniejszym elementem - BEGIN\n");
// Dopóki tablice się różnią trzeba sortować
while(PorownajTablice(tablica,posortowana_tablica, posortowana_tablica_rozmiar))
{
// Wybieranie najmniejszego nieposortowanego elementu
for(i=0;i<posortowana_tablica_rozmiar;i++)
{
// Chcemy najmniejszy element, czyli lecimy od najniższej pozycji, aby sprawdzić, jaki jest najmniejszy nieposortowany element.
// Porównujemy z posortowaną tablicą.
if(WezElement(i) != tablica[i])
{
najm_el = WezElement(i);
for(j=0;j<sizeof(tablica)/sizeof(int);j++)
{
if(najm_el == tablica[j])
{
pozycja = j;
break;
}
}
break;
}
}
// Wypisujemy początkowy stan tablicy
WypiszTablice(tablica, sizeof(tablica)/sizeof(int));
printf("\n");
// Sortuj z kosztem, dopóki najmniejszy element nie jest na swoim miejscu
while(WezPozycje(najm_el) != pozycja)
{
for(i=0;i<sizeof(tablica)/sizeof(int);i++)
{
if(WezPozycje(tablica[i]) == pozycja)
{
koszt += tablica[i] + najm_el;
int pom = tablica[i];
tablica[i] = tablica[pozycja];
tablica[pozycja] = pom;
pozycja = i;
printf("Pozycja: %d\n", pozycja);
break;
}
}

WypiszTablice(tablica, sizeof(tablica)/sizeof(int));
printf("najm:%d poz:%d koszt:%d\n\n", najm_el, pozycja, koszt);
}
}
printf("Sortowanie najmniejszym elementem - END\n");
printf("\nPosortowana ");
WypiszTablice(tablica, sizeof(tablica)/sizeof(int));
printf("Calkowity koszt: %d\n", koszt);
getchar();

return 0;
}