Sortowanie: swap was not declared in this scope

0

Cześć :) Mam problem z programem sortującym - w wierszu 132 pojawia się komunikat "swap was not declared in this scope". Ktoś może ma jakiś pomysł, dlaczego to nie działa?

#pragma warning(disable : 144)
#include <stdio.h>
#include <stdlib.h>
#include <ctime>
void funkcja(int tablica[], int a)
{
    int i;
    for (i = 0; i < a; i++)
    {
        tablica[i] = (rand() % 201) - 100;
    }
}
void inverted(int tablica[], int a)
{
    int i, temporary;
    for (int i = 0; i < a / 2; i++) {
        temporary = tablica[a - i - 1];
        tablica[a - i - 1] = tablica[i];
        tablica[i] = temporary;
    }
}
void bubblesort(int tablica[], int b)
{
    int x;
    for (int i = 0; i < b; i++)
    {
        for (int j = b - 1; j > i; j--)
            if (tablica[j] < tablica[j - 1])
            {
                x = tablica[j - 1]; 
				tablica[j - 1] = tablica[j]; 
				tablica[j] = x;
            }
    }
}
void insertion(int tablica[], int b)
{
    int j, x;
    for (int i = 1; i < b; i++)
    {
        j = i; x = tablica[j];
        while (tablica[j - 1] > x && j > 0)
        {
            tablica[j] = tablica[j - 1];
            j--;
        }
        tablica[j] = x;
    }
}
void selection(int tablica[], int b)
{
    int k, x;
    for (int i = 0; i < b - 1; i++)
    {
        k = i; x = tablica[i];
        for (int j = i + 1; j < b; j++)
            if (tablica[j] < x)
            {
                k = j; x = tablica[j];
            }
        if (k != i) { tablica[k] = tablica[i]; tablica[i] = x; }
    }
}

void quick(int tablica[], int c, int k)
{
    int i, j, x, wybrany;
    i = c; j = k;
    wybrany = tablica[rand() % (c - k) + c];

    while (i < j)
    {
        while (tablica[i] < wybrany) i++;
        while (tablica[j] > wybrany) j--;
        if (i <= j)
        {
            x = tablica[i]; tablica[i] = tablica[j]; tablica[j] = x;
            i++; j--;
        }
    }
    if (i < k) { quick(tablica, i, k); }
    if (c < j) { quick(tablica, c, j); }
}
void shell(int tablica[], int b)
{
    int i, j, y, z;
    for (z = 1; z < b; z = 3 * z + 1);
    z = z/9;
    if (!z) z++;
    while (z)
    {
        for (j = b - z - 1; j >= 0; j--)
        {
            y = tablica[j];
            i = j + z;
            while ((i < b) && (y > tablica[i]))
            {
                tablica[i - z] = tablica[i];
                i = i+z;
            }
            tablica[i - z] = y;
        }
        z = z/3;
    }
}
void heapify(int *tab, int n, int i) 
{ 
	int maxymalny = i;
	int swap;
    int lewy = 2 * i + 1;
    int prawy = 2 * i + 2;

    if (lewy < n && tab[lewy] > tab[maxymalny])
        maxymalny = lewy;

    if (prawy < n && tab[prawy] > tab[maxymalny])
        maxymalny = prawy;

    if (maxymalny != i) 
	{
        *swap(&tab[i], &tab[maxymalny]);
        heapify(tab, n, maxymalny);
    }
}

void heapsort(int *tab, int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(tab, n, i);

    for (int i = n - 1; i >= 0; i--) 
	{
        *swap(&tab[0], &tab[i]);
        heapify(tab, i, 0);
    }
}
int main()
{
    int i, j, elementy;
    int array[100000];
    clock_t start, end;
    time_t ts, tk;
    float diff;
    srand(time(NULL));

    printf("Liczba elementow do posortowania: \n");
    scanf("%d", &elementy);


    for (j = 1; j < 7; j++)
    {
        funkcja(array, elementy);
        if (j == 1)
        {
            time(&ts); start = clock();
            bubblesort(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            // printf("\n %f \n", start);
            printf("\nczas wykonania bubblesort w kolejnosci losowej: %f sec\n", diff / 100);

            time(&ts); start = clock();
            bubblesort(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania bubblesort w kolejnosci uporzadkowanej: %f sec\n", diff / 100);

            inverted(array, elementy);
            time(&ts); start = clock();
            bubblesort(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania bubblesort w kolejnosci odwrotnej: %f sec\n", diff / 100);
            printf(" \n \n");

        }
        if (j == 2)
        {
            time(&ts); start = clock();
            insertion(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania insertionsort w kolejnosci losowej: %f sec\n", diff / 100);

            time(&ts); start = clock();
            insertion(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania insertion w kolejnosci uporzadkowanej: %f sec\n", diff / 100);

            inverted(array, elementy);
            time(&ts); start = clock();
            insertion(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania insertionsort w kolejnosci odwrotnej: %f sec\n", diff / 100);
            printf(" \n \n");
        }
        if (j == 3)
        {
            time(&ts); start = clock();
            selection(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania selectionsort w kolejnosci losowej:: %f sec\n", diff / 100);

            time(&ts); start = clock();
            selection(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania selectionsort w kolejnosci uporzadkowanej: %f sec\n", diff / 100);

            inverted(array, elementy);
            time(&ts); start = clock();
            selection(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania selectionsort w kolejnosci odwrotnej: %f sec\n", diff / 100);
            printf(" \n \n");
        }
        if (j == 4)
        {
            time(&ts); start = clock();
            heapsort(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania heapsort w kolejnosci losowej: %f sec\n", diff / 100);

            time(&ts); start = clock();
            heapsort(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania heapsort w kolejnosci uporzadkowanej:: %f sec\n", diff / 100);

            inverted(array, elementy);
            time(&ts); start = clock();
            heapsort(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania heapsort w kolejnosci odwrotnej: %f sec\n", diff / 100);
            printf(" \n \n");
        }
        if (j == 5)
        {
            time(&ts); start = clock();
            quick(array, 0, elementy - 1);;
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania quicksort w kolejnosci losowej:: %f sec\n", diff / 100);

            time(&ts); start = clock();
            quick(array, 0, elementy - 1);;
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania quicksort w kolejnosci uporzadkowanej:: %f sec\n", diff / 100);

            inverted(array, elementy);
            time(&ts); start = clock();
            quick(array, 0, elementy - 1);;
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania quicksort w kolejnosci odwrotnej: %f sec\n", diff / 100);
            printf(" \n \n");
        }
        if (j == 6)
        {
            time(&ts); start = clock();
            shell(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania shellsort w kolejnosci losowej: %f sec\n", diff / 100);

            time(&ts); start = clock();
            shell(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania shellsort w kolejnosci uporzadkowanej:: %f sec\n", diff / 100);

            inverted(array, elementy);
            time(&ts); start = clock();
            shell(array, elementy);
            time(&tk); end = clock();
            diff = difftime(end, start);
            printf("\nczas wykonania shellsort w kolejnosci odwrotnej: %f sec\n", diff / 100);
            printf(" \n \n");
        }

    }
    system("pause");
}

1

Nie ma swap w C, dopiero w C++

0

A czy możesz mi doradzić, czym to zastąpić?

3

void swap(int *a,int *b)
{
    a*^=*b;
    b*^=*a;
    a*^=*b;
}

// wywołanie
swap(&tab[i], &tab[maxymalny]);
swap(tab+i,tab+maxymalny);

Zamiast kaskady ifów ztablicuj funkcje:

#include <time.h>
#include <stdio.h>
#include <stdlib.h>

void swap(int *a,int *b)
{
    *a^=*b;
    *b^=*a;
    *a^=*b;
}

void bubblesort(int *tab, int n)
{
	printf("bubblesort\n");
}

void heapsort(int *tab, int n)
{
	printf("heapsort\n");
}

void shell(int *tab, int n)
{
	printf("shell\n");
}

void quick(int *tab, int n)
{
	printf("quick\n");
}

void randomArray(int *tab,int count)
{
    int i;
    for(i=0;i<count;++i) tab[i]=(rand()%201)-100;
}

void invert(int *tab,int count)
{
    for(int i=0,k=count-1;i<k;++i,--k) swap(tab+i,tab+k);
}

void nothing(int *tab,int count)
{
}

typedef void anysort(int *tab,int n);
struct NamedCall { const char *name; anysort *fun; };

struct NamedCall sorts[]=
{
    { "bąbelkowe", &bubblesort },
    { "heap", &heapsort },
    { "shell", &shell },
    { "szybkie", &quick },
};

struct NamedCall prepares[]=
{
    { "losowa", &randomArray },
    { "posortowana", &nothing },
    { "odwrotna", &invert },
};

void call(int p,int s,int *tab,int count)
{
	clock_t start, end, diff;
	prepares[p].fun(tab,count);
	start=clock();
	sorts[s].fun(tab,count);
	end=clock();
	printf("czas wykonania %s w kolejnosci %s: %f sec\n\n",sorts[s].name,prepares[p].name,difftime(end,start)/100.0);
}

int main()
{
    int count,array[100000];

    srand(time(NULL));  
    printf("Liczba elementow do posortowania: ");
    scanf("%d",&count);
    for(int s=0;s<sizeof(sorts)/sizeof(*sorts);++s)
    {
		for(int p=0;p<sizeof(prepares)/sizeof(*prepares);++p)
		{
    			call(p,s,array,count);
		}
    }
    return 0;
}

0

Dobra, teraz wysżło mi coś takiego - wciąż jest gdzieś błąd

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <cstdlib>
#include<iostream>

void funkcja(int tablica[], int a)
{
int i;
for (i = 0; i < a; i++)
{
tablica[i] = (rand() % 201) - 100;
}
}

void bubblesort(int tablica[], int b)
{
int x;
for (int i = 0; i < b; i++)
{
for (int j = b - 1; j > i; j--)
if (tablica[j] < tablica[j - 1])
{
x = tablica[j - 1];
tablica[j - 1] = tablica[j];
tablica[j] = x;
}
}
}

void shell(int tablica[], int b)
{
int i, j, y, z;
for (z = 1; z < b; z = 3 * z + 1);
z = z/9;
if (!z) z++;
while (z)
{
for (j = b - z - 1; j >= 0; j--)
{
y = tablica[j];
i = j + z;
while ((i < b) && (y > tablica[i]))
{
tablica[i - z] = tablica[i];
i = i+z;
}
tablica[i - z] = y;
}
z = z/3;
}
}
void quick(int tablica[], int c, int k)
{
int i, j, x, wybrany;
i = c; j = k;
wybrany = tablica[rand() % (c - k) + c];

while (i < j)
{
    while (tablica[i] < wybrany) i++;
    while (tablica[j] > wybrany) j--;
    if (i <= j)
    {
        x = tablica[i]; tablica[i] = tablica[j]; tablica[j] = x;
        i++; j--;
    }
}
if (i < k) { quick(tablica, i, k); }
if (c < j) { quick(tablica, c, j); }

}

void heapify(int *tab, int n, int i)
{
int maxymalny = i;
int swap;

int lewy = 2 * i + 1;
int prawy = 2 * i + 2;

if (lewy < n && tab[lewy] > tab[maxymalny])
    maxymalny = lewy;

if (prawy < n && tab[prawy] > tab[maxymalny])
    maxymalny = prawy;

if (maxymalny != i) 
{
    std::swap(&tab[i], &tab[maxymalny]);
    heapify(tab, n, maxymalny);
}

}

void heapsort(int *tab, int n) {
for (int i = n / 2 - 1; i >= 0; i--)
heapify(tab, n, i);

for (int i = n - 1; i >= 0; i--) 
{
    std::swap(&tab[0], &tab[i]);
    heapify(tab, i, 0);
}

}
void insertion(int tablica[], int b)
{
int j, x;
for (int i = 1; i < b; i++)
{
j = i; x = tablica[j];
while (tablica[j - 1] > x && j > 0)
{
tablica[j] = tablica[j - 1];
j--;
}
tablica[j] = x;
}
}

void inverted(int tablica[], int a)
{
int i, temporary;
for (int i = 0; i < a / 2; i++) {
temporary = tablica[a - i - 1];
tablica[a - i - 1] = tablica[i];
tablica[i] = temporary;
}
}

void selection(int tablica[], int b)
{
int k, x;
for (int i = 0; i < b - 1; i++)
{
k = i; x = tablica[i];
for (int j = i + 1; j < b; j++)
if (tablica[j] < x)
{
k = j; x = tablica[j];
}
if (k != i) { tablica[k] = tablica[i]; tablica[i] = x; }
}
}

void randomArray(int *tab,int count)
{
int i;
for(i=0;i<count;++i) tab[i]=(rand()%201)-100;
}

typedef void anysort(int *tab,int n);

anysort *sorts[]=
{
&bubblesort,
&heapsort,
&shell,
&quick,
&insertion,
&selection,
};

int main()
{
int i,licz,array[100000];

srand(time(NULL));  
printf("Liczba elementow do posortowania: ");
scanf("%d",&licz);
for(i=0;i<sizeof(sorts)/sizeof(*sorts);++i)
{
    randomArray(array,licz);

    sorts[i](array,licz);
}
return 0;

}

0

Ciągle jest z tym problem ** std::swap(&tab[i], &tab[maxymalny]); **

Sortowanie: swap was not declared in this scope

1 użytkowników online, w tym zalogowanych: 0, gości: 1

Praca dla programistów

Forum dyskusyjne

Sprawy administracyjne

O nas

Skontaktuj się z nami