| ZER DAKIDAN: Zenbaki errealen array datu-motako aldagai batekin lan eginez, oinarrizko algoritmo batzuk programatzen ikasi dut. ZER IKASIKO DUDAN: Zenbaki errealen array datu-motako aldagai batekin lanean jarraituz, beste algoritmo batzuk programatzen ikasiko dut. |
Ezagutzen dugun zarekin jarraituz. Gogora ekar dezagun zenbaki errealen afBektorea izeneko array-aldagiak gehienez LUZMAX=20 elementu izan ditzakeela, eta bektore horrek 0.0 eta 99.9 zenbaki errealak gordetzen dituela. Adibidez, une jakin batean 5 elementu dituen afBektorea array horren edukia hau izan daiteke, non iLuzera aldagaiak bektorearen luzera efektiboa gordetzen duen:
afBektorea
62.70
|
17.68
| 32.21
|
98.41
|
9.82
| ||
0
|
1
|
2
|
3
|
4
|
...
|
19
|
5
|
Gogoratu ere iLuzera aldagaiak bektorearen luzera efektiboa gordetzen duela, hots, zenbat elementu dituen une horretan, bere mugak 0 eta LUZMAX=20 dira. Beraz, bektorea beterik izatean iLuzera aldagaian LUZMAX=20 balioa gordeko da, eta, aldiz, bektorea hutsik izatean iLuzera aldagaian 0 marka gordeko da.
Bere posizioa ezaguna delarik, arrayaren elementu bat aldatu edo ordeztu. Elementu berriaren balioa teklatuz irakurriko da.
Aurreko programa batean erabiltzaileak teklatuz erabakitzen zuen bektorean gordeko diren elementuen kopurua. Orain, iLuzera kopurua modu aleatorioan lortuko da (gehienez 20 elementu: 0. posiziotik 19. posizioraino), eta, modu aleatorioan ere 0.0 eta 99.99 arteko zenbakiak bektorean biltegituko dira. Funtzio nagusian ondoko funtzioak deituko dira: BektoreaAleatoriokiBete() eta BektoreaIkusi().
Elementu bat aldatzeko, onargarria den bere posizioa teklatuz eman eta posizio horretako arrayaren elementua ordeztu. Lehen hurbilpen honetan, elementu berriaren balioa teklatuz irakurriko da (0.0 eta 99.99 arteko kopurua, noski).
/* Ariketa-46a1_ElementuBatAldatu: arrayaren elementu bat aldatu */
// Errealekin lan eginez. Array bat datuz auzaz bete funtzio batean
// eta ondoren arrayaren bere elementu baten balioa ordeztu.
#include <stdio.h>
#include <stdlib.h> // rand() eta srand() funtzioetarako
#include <time.h> // time() funtzioarako
#define BEHEMUGA 0.0
#define GOIMUGA 99.9
#define LUZMAX 20 // 20 elementu gehienez: 0. posiziotik 19. posizionarino
void BektoreaAleatoriokiBete(float[], int);
void BektoreaIkusi(const float[], int);
void BektorearenDatuBatOrdeztu1(float[], int);
int main()
{
float afBektorea[LUZMAX];
int iLuzera;
int iPosizioa;
printf("\n");
printf("\n\t Zerrenda auzaz betetzen zenbaki errealez");
printf("\n\t ----------------------------------------\n");
srand(time(NULL)); // srand() zenbaki aleatorioak berriro hasiarazteko, hazia behar du
// time(NULL) funtzioak igarotako segundoak itzultzen ditu 1970-01-01 datatik hasita
iLuzera = rand() % LUZMAX + 1; // [hondarra + 1] = [(0 eta 19 artekoa) + 1] gutxienez elementu bat
// printf("\n %d \t\t %d", iKont, iLuzera);
printf("\n\t %d datu auzaz hartuko dira, %.1f eta %.1f arteko balioekin. \n", iLuzera, BEHEMUGA, GOIMUGA);
BektoreaAleatoriokiBete(afBektorea, iLuzera);
printf("\n\t Arrayaren iLuzera=%d elementuak: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n Eman posizioa eta bertan jarri nahi dugun elementu berria (aurrekoa galduko da)\n");
do
{
printf(" Zein posizioatan gordeko da elementu berria? (0 eta %d artekoa): ", iLuzera-1);
scanf("%d", &iPosizioa);
} while ((iPosizioa < 0) || (iPosizioa >= iLuzera));
BektorearenDatuBatOrdeztu1(afBektorea, iPosizioa);
printf("\n\t Arrayaren elementu berriak: \n");
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
return 0;
}
void BektoreaAleatoriokiBete(float afBektorea[], int iLuzera) // lehen parametroa irteerakoa da
{ // bigarren parametroa sarrerakoa da
int iKont;
// printf("\n");
// printf("\n\t [%.2f <= BalioOnargarria <= %.2f]", BEHEMUGA, GOIMUGA);
// printf("\n\t ----------------------------------");
srand(time(NULL)); // srand() zenbaki aleatorioak berriro hasiarazteko, hazia behar du
// time(NULL) funtzioak igarotako segundoak itzultzen ditu 1970-01-01 datatik hasita
for (iKont=0; iKont < iLuzera; iKont++)
{
afBektorea[iKont] = ((float)rand()/RAND_MAX) * (GOIMUGA-BEHEMUGA); // 0.0 eta 0.999 artekoa bider (GOIMUGA-BEHEMUGA)
// printf("\n %15.2f (0.0 eta %.2f artekoa)", afBektorea[iKont], GOIMUGA-BEHEMUGA); // 0.0 eta 99.9 artekoa
}
// printf("\n");
}
void BektoreaIkusi(const float afBektorea[], int iLuzera) // bi parametroak sarrerakoak
{
int iKont;
// afBektorea[3] = 3.33; babestuta dago
printf("\n");
printf("\t Posizioa Balioa\n");
printf("\t -------- ------\n");
for (iKont=0; iKont < iLuzera; iKont++)
{
printf("\t %9d %13.2f\n", iKont, afBektorea[iKont]);
}
}
void BektorearenDatuBatOrdeztu1(float afBektorea[], int iPosizioa)
{
float fDatuBerria;
printf("\n");
do
{
printf(" %d. posizioko elementu berriaren balioa eman (0.0 eta 99.9 artekoa): ", iPosizioa);
scanf("%f", &fDatuBerria);
} while ((fDatuBerria < 0.0) || (fDatuBerria >= 100));
afBektorea[iPosizioa] = fDatuBerria;
}
Bere posizioa ezaguna delarik, arrayaren elementu bat aldatu edo ordeztu. Elementu berriaren balioa kalkulu bat izango da.
Aurreko programa batean erabiltzaileak teklatuz erabakitzen zuen bektorean gordeko diren elementuen kopurua. Orain, iLuzera kopurua modu aleatorioan lortuko da (gehienez 20 elementu: 0. posiziotik 19. posizioraino), eta, modu aleatorioan ere 0.0 eta 99.99 arteko zenbakiak bektorean biltegituko dira. Funtzio nagusian ondoko funtzioak deituko dira: BektoreaAleatoriokiBete() eta BektoreaIkusi().
Onargarria den posizio teklatuz eman eta posizio horretako arrayaren elementua ordeztu. Bigarren hurbilpen honetan, elementu berriaren balioa kalkulu batetik lortuko dugu:
- Teklatuz emandako posizioa 0 izatean, elementu berria bektorearen lehen posizioan kokatuko da eta bere balioa azken posizioko elementuaren erdia izango da.
- Teklatuz emandako posizioa iLuzera-1 izatean, elementu berria bektoreari azken posizioan kokatuko da eta elementu berriaren balioa lehen posizioko elementuaren doblea izango da.
- Emandako posizioa 1 eta iLuzera-2 bitartekoa izatean (biak barne), elementu berriaren balioa bere inguruko bi posizioetako zenbakien batezbesteko aritmetikoa izango da.
/* Ariketa-46a2_ElementuBatAldatu: arrayaren elementu bat aldatu */
// Errealekin lan eginez. Array bat datuz auzaz bete funtzio batean
// eta ondoren arrayaren bere elementu baten balioa ordeztu.
#include <stdio.h>
#include <stdlib.h> // rand() eta srand() funtzioetarako
#include <time.h> // time() funtzioarako
#define BEHEMUGA 0.0
#define GOIMUGA 99.9
#define LUZMAX 20 // 20 elementu gehienez: 0. posiziotik 19. posizionarino
void BektoreaAleatoriokiBete(float[], int);
void BektoreaIkusi(const float[], int);
void BektorearenDatuBatOrdeztu2(float[], int, int);
int main()
{
float afBektorea[LUZMAX];
int iLuzera;
int iPosizioa;
printf("\n");
printf("\n\t Zerrenda auzaz betetzen zenbaki errealez");
printf("\n\t ----------------------------------------\n");
srand((unsigned int)time(NULL)); // srand() zenbaki aleatorioak berriro hasiarazteko, hazia behar du
// time(NULL) funtzioak igarotako segundoak itzultzen ditu 1970-01-01 datatik hasita
iLuzera = (rand() % LUZMAX) + 1; // (hondarra + 1) = [(0 eta 19 artekoa) + 1]
// printf("\n %d \t\t %d", iKont, iLuzera);
printf("\n\t %d datu auzaz hartuko dira, %.1f eta %.1f arteko balioekin. \n", iLuzera, BEHEMUGA, GOIMUGA);
BektoreaAleatoriokiBete(afBektorea, iLuzera);
printf("\n\t Arrayaren iLuzera=%d elementuak: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n Eman posizioa eta bertan jarri nahi dugun elementu berria (aurrekoa galduko da)\n");
do
{
printf(" Zein posizioatan gordeko da elementu berria? (0 eta %d artekoa): ", iLuzera-1);
scanf("%d", &iPosizioa);
} while ((iPosizioa < 0) || (iPosizioa >= iLuzera));
BektorearenDatuBatOrdeztu2(afBektorea, iLuzera, iPosizioa);
printf("\n\t Arrayaren elementu berriak: \n");
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
return 0;
}
void BektoreaAleatoriokiBete(float afBektorea[], int iLuzera) // lehen parametroa irteerakoa da
{ // bigarren parametroa sarrerakoa da
int iKont;
// printf("\n");
// printf("\n\t [%.2f <= BalioOnargarria <= %.2f]", BEHEMUGA, GOIMUGA);
// printf("\n\t ----------------------------------");
srand(time(NULL)); // srand() zenbaki aleatorioak berriro hasiarazteko, hazia behar du
// time(NULL) funtzioak igarotako segundoak itzultzen ditu 1970-01-01 datatik hasita
for (iKont=0; iKont < iLuzera; iKont++)
{
afBektorea[iKont] = ((float)rand()/RAND_MAX) * (GOIMUGA-BEHEMUGA); // 0.0 eta 0.999 artekoa bider (GOIMUGA-BEHEMUGA)
// printf("\n %15.2f (0.0 eta %.2f artekoa)", afBektorea[iKont], GOIMUGA-BEHEMUGA); // 0.0 eta 99.9 artekoa
}
// printf("\n");
}
void BektoreaIkusi(const float afBektorea[], int iLuzera) // bi parametroak sarrerakoak
{
int iKont;
// afBektorea[3] = 3.33; // babestuta dago
printf("\n");
printf("\t Posizioa Balioa\n");
printf("\t -------- ------\n");
for (iKont=0; iKont < iLuzera; iKont++)
{
printf("\t %9d %13.2f\n", iKont, afBektorea[iKont]);
}
}
void BektorearenDatuBatOrdeztu2(float afBektorea[], int iLuzera, int iPosizioa)
{
float fDatuBerria;
printf("\n");
if (iPosizioa == 0)
{
fDatuBerria = afBektorea[iLuzera-1] / 2;
afBektorea[iPosizioa] = fDatuBerria;
}
if (iPosizioa == iLuzera-1)
{
fDatuBerria = afBektorea[0] * 2;
afBektorea[iPosizioa] = fDatuBerria;
}
if (iPosizioa > 0 && iPosizioa < iLuzera-1)
{
fDatuBerria = (afBektorea[iPosizioa-1] + afBektorea[iPosizioa+1]) / 2;
afBektorea[iPosizioa] = fDatuBerria;
}
}
Datuak dituen array batean elementu berri bat gehituko da bere bukaeran. Horretarako, lehenik eta behin frogatu beharko da arrayan toki librerik dagoela. Baiezkoan, elementu berriaren balioa teklatuz irakurri ondoren iLuzera posizioan gordeko da, eta, ondoren, iLuzera inkrementatu beharko da unitate batean.
/* Ariketa-46b_ElementuBerriaGehitu: elementu berri bat gehitu */
// Array baten hasieraketa. Datuak dituen array batean elementu berri bat
// gehituko da bukaeran baldin eta tokirik badago. Elementu berriaren
// balioa teklatuz emango da (0.0 eta 99.9 artekoa).
#include <stdio.h>
#define BEHEMUGA 0.0
#define GOIMUGA 99.9
#define LUZMAX 10 // 20 elementu gehienez: 0. posiziotik 19. posizionarino
void BektoreaIkusi(const float[], int);
void ElementuBatGehitu(float[], int *);
int main()
{
static float afBektorea[LUZMAX] = { 67.34, 2.17, 89.37, 15.08, 16.16, 72.44, 5.09, 38.77 };
int iLuzera = 8;
printf("\n");
printf("\n\t Arrayaren eta bere luzera efektiboaren hasieraketak");
printf("\n\t ---------------------------------------------------\n");
printf("\n\t Arrayaren iLuzera=%d elementuak hasieraketa ondoren: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
if (iLuzera == LUZMAX)
printf("\n\t Arraya beterik dago eta ez da elementu gehiagorik onartzen! \n");
else
{
ElementuBatGehitu(afBektorea, &iLuzera);
printf("\n\t Balio berria gehitu ondoren: \n");
BektoreaIkusi(afBektorea, iLuzera);
}
printf("\n");
return 0;
}
void BektoreaIkusi(const float afBektorea[], int iLuzera) // bi parametroak sarrerakoak
{
int iKont;
// afBektorea[3] = 3.33; // babestuta dago
printf("\n");
printf("\t Posizioa Balioa\n");
printf("\t -------- ------\n");
for (iKont=0; iKont < iLuzera; iKont++)
{
printf("\t %9d %13.2f\n", iKont, afBektorea[iKont]);
}
}
void ElementuBatGehitu(float afBektorea[], int *iLuzera) // bi parametroak irterakoak dira
{
float fDatuBerria;
printf("\n");
do
{
printf(" %d. posizioko elementu berriaren balioa eman (0.0 eta 99.9 artekoa): ", *iLuzera);
scanf("%f", &fDatuBerria);
} while (fDatuBerria < 0.0 || fDatuBerria >= 100);
afBektorea[*iLuzera] = fDatuBerria;
*iLuzera = *iLuzera + 1;
}
Arrayaren azken elementua kentzea oso eragiketa erraza da, nahikoa da iLuzera luzera efektiboa dekrementatzea.
/* Ariketa-46c_AzkenElementuaKendu: arrayaren azken elementua kendu */
// Array baten hasieraketa. Datuak dituen array batean azken elementua kenduko da.
#include <stdio.h>
#define BEHEMUGA 0.0
#define GOIMUGA 99.9
#define LUZMAX 10 // 20 elementu gehienez: 0. posiziotik 19. posizionarino
void BektoreaIkusi(const float[], int);
int main()
{
static float afBektorea[LUZMAX] = { 67.34, 2.17, 89.37, 15.08, 16.16, 72.44, 5.09, 38.77 };
int iLuzera = 8;
printf("\n");
printf("\n\t Arrayaren eta bere luzera efektiboaren hasieraketak");
printf("\n\t ---------------------------------------------------\n");
printf("\n\t Arrayaren iLuzera=%d elementuak hasieraketa ondoren: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
iLuzera = iLuzera - 1; // azken elementua kendu
printf("\n\t Arrayaren iLuzera=%d elementuak azkena kendu ondoren: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
return 0;
}
void BektoreaIkusi(const float afBektorea[], int iLuzera) // bi parametroak sarrerakoak
{
int iKont;
// afBektorea[3] = 3.33; babestuta dago
printf("\n");
printf("\t Posizioa Balioa\n");
printf("\t -------- ------\n");
for (iKont=0; iKont < iLuzera; iKont++)
{
printf("\t %9d %13.2f\n", iKont, afBektorea[iKont]);
}
}
Bere posizioa ezaguna delarik, arrayan elementu berri bat sartu. Elementu berriaren balioa teklatuz irakurriko da.
Datuak dituen array batean elementu berri bat txertatu. Horretarako, lehenik eta behin frogatu beharko da arrayan toki librerik dagoela. Baiezkoan, helburuko posizio teklatuz irakurriko da (0 eta iLuzera-1 balio bat), ondoren elementu berri bat sartuko da arrayan ElementuBatTxertatu1() funtzioaren bitartez, zeinek array laguntzaile bat erabiliz.
/* Ariketa-46d1_ElementuBerriaTxertatu: elementu berri bat txertatu
array laguntzaile bat erabiliz */
// Array baten hasieraketa. Datuak dituen array batean elementu berri bat
// txertatuko dugu baldin eta tokirik badago. Elementu berriaren posizioa
// teklatuz emango da (0 eta iLuzera-1 arteko posizioa, biak barne).
#include <stdio.h>
#define BEHEMUGA 0.0
#define GOIMUGA 99.9
#define LUZMAX 20 // 20 elementu gehienez: 0. posiziotik 19. posizionarino
void BektoreaIkusi(const float[], int);
void ElementuBatTxertatu1(float[], int *, int);
int main()
{
static float afBektorea[LUZMAX] = { 67.34, 2.17, 89.37, 15.08, 6.16, 72.44, 5.09, 38.77, 94.06 };
int iLuzera = 9;
int iPosizioa;
printf("\n");
printf("\n\t Arrayaren eta bere luzera efektiboaren hasieraketak");
printf("\n\t ---------------------------------------------------\n");
printf("\n\t Arrayaren iLuzera=%d elementuak hasieraketa ondoren: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
if (iLuzera == LUZMAX)
printf("\n\t Arraya beterik dago eta ez da elementu gehiagorik onartzen! \n");
else
{
printf("\n");
do
{
printf(" Zein posizioatan txertatuko da elementu berria? (0 eta %d artekoa): ", iLuzera-1);
scanf("%d", &iPosizioa);
} while (iPosizioa < 0 || iPosizioa >= iLuzera);
ElementuBatTxertatu1(afBektorea, &iLuzera, iPosizioa);
printf("\n\t %d. indizeko posizioan balio berria txertatu ondoren: \n", iPosizioa);
BektoreaIkusi(afBektorea, iLuzera);
}
printf("\n");
return 0;
}
void BektoreaIkusi(const float afBektorea[], int iLuzera) // bi parametroak sarrerakoak
{
int iKont;
// afBektorea[3] = 3.33; babestuta dago
printf("\n");
printf("\t Posizioa Balioa\n");
printf("\t -------- ------\n");
for (iKont=0; iKont < iLuzera; iKont++)
{
printf("\t %9d %13.2f\n", iKont, afBektorea[iKont]);
}
}
void ElementuBatTxertatu1(float afBektorea[], int *iLuzera, int iPosizioa) // bi parametroak irteerakoak dira
{ // hirugarren parametroa sarrerakoa
float fDatuBerria;
int iKont;
float afLaguntzailea[LUZMAX];
printf("\n");
do
{
printf(" %d. posizioko elementu berriaren balioa eman (0.0 eta 99.9 artekoa): ", *iLuzera);
scanf("%f", &fDatuBerria);
} while (fDatuBerria < 0.0 || fDatuBerria >= 100.0);
// afBektorea[] arrayaren [0] posiziotik [iPosizioa-1] posizioraino afLaguntzailea[] kargatu
for (iKont = 0; iKont < iPosizioa; iKont++)
{
afLaguntzailea[iKont] = afBektorea[iKont];
}
// [iPosizioa] posizioan datu berria gorde afLaguntzailea[] arrayan
afLaguntzailea[iPosizioa] = fDatuBerria;
// afBektorea[] arrayaren [iPosizioa] posiziotik [iLuzera] posizioraino afLaguntzailea[] kargatu
for (iKont = iPosizioa; iKont < *iLuzera; iKont++)
{
afLaguntzailea[iKont+1] = afBektorea[iKont];
}
// luzera efektiboa inkrementatu
*iLuzera = *iLuzera + 1;
// afLaguntzailea[] arraytik abiatuta afBektorea[] arraya kargatu
for (iKont = 0; iKont < *iLuzera; iKont++)
{
afBektorea[iKont] = afLaguntzailea[iKont];
}
}
Bere posizioa ezaguna delarik, arrayan elementu berri bat sartu. Elementu berriaren balioa teklatuz irakurriko da.
Datuak dituen array batean elementu berri bat txertatu. Horretarako, lehenik eta behin frogatu beharko da arrayan toki librerik dagoela. Baiezkoan, helburuko posizio teklatuz irakurriko da (0 eta iLuzera-1 balio bat), ondoren elementu berri bat sartuko da arrayan ElementuBatTxertatu2() funtzioaren bitartez, zeinek array laguntzailerik ez da erabiltzen.
/* Ariketa-46d2_ElementuBerriaTxertatu: elementu berri bat txertatu
array laguntzailerik gabe */
// Array baten hasieraketa. Datuak dituen array batean elementu berri bat
// txertatuko dugu baldin eta tokirik badago. Elementu berriaren posizioa
// teklatuz emango da (0 eta iLuzera-1 arteko posizioa, biak barne).
#include <stdio.h>
#define BEHEMUGA 0.0
#define GOIMUGA 99.9
#define LUZMAX 20 // 20 elementu gehienez: 0. posiziotik 19. posizionarino
void BektoreaIkusi(const float[], int);
void ElementuBatTxertatu2(float[], int *, int);
int main()
{
static float afBektorea[LUZMAX] = { 67.34, 2.17, 89.37, 15.08, 16.16, 72.44, 5.09, 38.77 };
int iLuzera = 8;
int iPosizioa;
printf("\n");
printf("\n\t Arrayaren eta bere luzera efektiboaren hasieraketak");
printf("\n\t ---------------------------------------------------\n");
printf("\n\t Arrayaren iLuzera=%d elementuak hasieraketa ondoren: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
if (iLuzera == LUZMAX)
printf("\n\t Arraya beterik dago eta ez da elementu gehiagorik onartzen! \n");
else
{
printf("\n");
do
{
printf(" Zein posizioatan txertatuko da elementu berria? (0 eta %d artekoa): ", iLuzera-1);
scanf("%d", &iPosizioa);
} while (iPosizioa < 0 || iPosizioa >= iLuzera);
ElementuBatTxertatu2(afBektorea, &iLuzera, iPosizioa);
printf("\n\t Balio berria txertatu ondoren: \n");
BektoreaIkusi(afBektorea, iLuzera);
}
printf("\n");
return 0;
}
void BektoreaIkusi(const float afBektorea[], int iLuzera) // bi parametroak sarrerakoak
{
int iKont;
// afBektorea[3] = 3.33; babestuta dago
printf("\n");
printf("\t Posizioa Balioa\n");
printf("\t -------- ------\n");
for (iKont=0; iKont < iLuzera; iKont++)
{
printf("\t %9d %13.2f\n", iKont, afBektorea[iKont]);
}
}
void ElementuBatTxertatu2(float afBektorea[], int *iLuzera, int iPosizioa) // bi parametroak irterakoak dira
{ // hirugarren parametroa sarrerakoa
float fDatuBerria;
int iKont;
printf("\n");
do
{
printf(" %d. posizioko elementu berriaren balioa eman (0.0 eta 99.9 artekoa): ", *iLuzera);
scanf("%f", &fDatuBerria);
} while (fDatuBerria < 0.0 || fDatuBerria >= 100.0);
for (iKont = *iLuzera-1; iKont >= iPosizioa; iKont--)
{
afBektorea[iKont+1] = afBektorea[iKont];
}
afBektorea[iPosizioa] = fDatuBerria;
*iLuzera = *iLuzera + 1;
}
Arraytik elementu bat kendu bere posizioa ezaguna delarik. Elementua kentzeko edo ezabatzeko ElementuBatKendu1() funtzioan egingo da, zeinek array laguntzaile bat erabiltzen duen.
/* Ariketa-46e1A_ElementuBakarraKendu: arraytik elementu bat kendu
array laguntzaile bat erabiliz */
// Array baten hasieraketa. Datuak dituen array batean elementu bat
// kenduko dugu. Kenduko den elementuaren posizioa teklatuz emango
// da (0 eta iLuzera-1 arteko posizioa, biak barne).
#include <stdio.h>
#define BEHEMUGA 0.0
#define GOIMUGA 99.9
#define LUZMAX 20 // 20 elementu gehienez: 0. posiziotik 19. posizionarino
void BektoreaIkusi(const float[], int);
void ElementuBatKendu1(float[], int *, int);
int main()
{
static float afBektorea[LUZMAX] = { 67.34, 2.17, 89.37, 15.08, 6.16, 72.44, 5.09, 38.77, 94.06 };
int iLuzera = 9;
int iPosizioa;
printf("\n");
printf("\n\t Arrayaren eta bere luzera efektiboaren hasieraketak");
printf("\n\t ---------------------------------------------------\n");
printf("\n\t Arrayaren iLuzera=%d elementuak hasieraketa ondoren: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
do
{
printf(" Zein posizioko elementua kenduko da? (0 eta %d artekoa): ", iLuzera-2);
scanf("%d", &iPosizioa);
} while (iPosizioa < 0 || iPosizioa >= iLuzera-1);
ElementuBatKendu1(afBektorea, &iLuzera, iPosizioa);
printf("\n\t %d. indizedun elementua kendu ondoren: \n", iPosizioa);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
return 0;
}
void BektoreaIkusi(const float afBektorea[], int iLuzera) // bi parametroak sarrerakoak
{
int iKont;
// afBektorea[3] = 3.33; babestuta dago
printf("\n");
printf("\t Posizioa Balioa\n");
printf("\t -------- ------\n");
for (iKont=0; iKont < iLuzera; iKont++)
{
printf("\t %9d %13.2f\n", iKont, afBektorea[iKont]);
}
}
// Hurrengo azpiatalean baliokidea den beste algoritmo bat
void ElementuBatKendu1(float afBektorea[], int *iLuzera, int iPosizioa) // bi parametroak irteerakoak dira
{ // hirugarren parametroa sarrerakoa
int iKont;
float afLaguntzailea[LUZMAX];
// afBektorea[] arrayaren [0] posiziotik [iPosizioa-1] posizioraino afLaguntzailea[] kargatu
for (iKont = 0; iKont <= iPosizioa; iKont++)
{
afLaguntzailea[iKont] = afBektorea[iKont];
}
// afBektorea[] arrayaren [iPosizioa+1] posiziotik [iLuzera] posizioraino afLaguntzailea[] kargatu
for (iKont = iPosizioa+1; iKont < *iLuzera; iKont++)
{
afLaguntzailea[iKont-1] = afBektorea[iKont];
}
// luzera efektiboa dekrementatu
*iLuzera = *iLuzera - 1;
// afLaguntzailea[] arraytik abiatuta afBektorea[] arraya kargatu
for (iKont = 0; iKont < *iLuzera; iKont++)
{
afBektorea[iKont] = afLaguntzailea[iKont];
}
}
Arraytik elementu bat kendu bere posizioa ezaguna delarik. Elementua kentzeko edo ezabatzeko ElementuBatKendu1() funtzioan egingo da, zeinek array laguntzaile bat erabiltzen duen.
/* Ariketa-46e1B_ElementuBakarraKendu: arraytik elementu bat kendu
array laguntzaile bat erabiliz */
// Array baten hasieraketa. Datuak dituen array batean elementu bat
// kenduko dugu. Kenduko den elementuaren posizioa teklatuz emango
// da (0 eta iLuzera-1 arteko posizioa, biak barne).
#include <stdio.h>
#define BEHEMUGA 0.0
#define GOIMUGA 99.9
#define LUZMAX 20 // 20 elementu gehienez: 0. posiziotik 19. posizionarino
void BektoreaIkusi(const float[], int);
void ElementuBatKendu1(float[], int *, int);
int main()
{
static float afBektorea[LUZMAX] = { 67.34, 2.17, 89.37, 15.08, 6.16, 72.44, 5.09, 38.77, 94.06 };
int iLuzera = 9;
int iPosizioa;
printf("\n");
printf("\n\t Arrayaren eta bere luzera efektiboaren hasieraketak");
printf("\n\t ---------------------------------------------------\n");
printf("\n\t Arrayaren iLuzera=%d elementuak hasieraketa ondoren: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
do
{
printf(" Zein posizioko elementua kenduko da? (0 eta %d artekoa): ", iLuzera-2);
scanf("%d", &iPosizioa);
} while (iPosizioa < 0 || iPosizioa >= iLuzera-1);
ElementuBatKendu1(afBektorea, &iLuzera, iPosizioa);
printf("\n\t %d. indizedun elementua kendu ondoren: \n", iPosizioa);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
return 0;
}
void BektoreaIkusi(const float afBektorea[], int iLuzera) // bi parametroak sarrerakoak
{
int iKont;
// afBektorea[3] = 3.33; babestuta dago
printf("\n");
printf("\t Posizioa Balioa\n");
printf("\t -------- ------\n");
for (iKont=0; iKont < iLuzera; iKont++)
{
printf("\t %9d %13.2f\n", iKont, afBektorea[iKont]);
}
}
// Aurreko azpiatalaren baliokidea den beste algoritmo bat
void ElementuBatKendu1(float afBektorea[], int *iLuzera, int iPosizioa) // bi parametroak irteerakoak dira
{ // hirugarren parametroa sarrerakoa
int iKont;
float afLaguntzailea[LUZMAX];
int iNonGorde;
// afBektorea[] arraytik abiatuta afLaguntzailea[] arraya kargatu
iNonGorde = -1; // afLaguntzailea[] hasieran hutsik
for (iKont = 0; iKont < *iLuzera; iKont++)
{
if (iKont != iPosizioa)
{
iNonGorde++;
afLaguntzailea[iNonGorde] = afBektorea[iKont];
}
}
printf("\n\t Array laguntzailea: iNonGorde+1=%d \n", iNonGorde+1);
BektoreaIkusi(afLaguntzailea, iNonGorde+1);
// afLaguntzailea[] arraytik abiatuta afBektorea[] arraya kargatu
for (iKont = 0; iKont <= iNonGorde; iKont++)
{
afBektorea[iKont] = afLaguntzailea[iKont];
}
// luzera efektiboa dekrementatu
*iLuzera = *iLuzera - 1;
}
Arraytik elementu bat kendu bere posizioa ezaguna delarik. Elementua kentzeko edo ezabatzeko ElementuBatKendu2() funtzioan egingo da, zeinek array laguntzailerik ez den erabiltzen.
/* Ariketa-46e2_ElementuBakarraKendu: arraytik elementu bat kendu
array laguntzailerik gabe */
// Array baten hasieraketa. Datuak dituen array batean elementu bat
// kenduko dugu. Kenduko den elementuaren posizioa teklatuz emango
// da (0 eta iLuzera-1 arteko posizioa, biak barne).
#include <stdio.h>
#define BEHEMUGA 0.0
#define GOIMUGA 99.9
#define LUZMAX 20 // 20 elementu gehienez: 0. posiziotik 19. posizionarino
void BektoreaIkusi(const float[], int);
void ElementuBatKendu2(float[], int *, int);
int main()
{
static float afBektorea[LUZMAX] = { 67.34, 2.17, 89.37, 15.08, 16.16, 72.44, 5.09, 38.77 };
int iLuzera = 8;
int iPosizioa;
printf("\n");
printf("\n\t Arrayaren eta bere luzera efektiboaren hasieraketak");
printf("\n\t ---------------------------------------------------\n");
printf("\n\t Arrayaren iLuzera=%d elementuak hasieraketa ondoren: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
do
{
printf(" Zein posizioko elementua kenduko da? (0 eta %d artekoa): ", iLuzera-2);
scanf("%d", &iPosizioa);
} while (iPosizioa < 0 || iPosizioa >= iLuzera-1);
ElementuBatKendu2(afBektorea, &iLuzera, iPosizioa);
printf("\n\t %d. indizedun elementua kendu ondoren: \n", iPosizioa);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
return 0;
}
void BektoreaIkusi(const float afBektorea[], int iLuzera) // bi parametroak sarrerakoak
{
int iKont;
// afBektorea[3] = 3.33; babestuta dago
printf("\n");
printf("\t Posizioa Balioa\n");
printf("\t -------- ------\n");
for (iKont=0; iKont < iLuzera; iKont++)
{
printf("\t %9d %13.2f\n", iKont, afBektorea[iKont]);
}
}
void ElementuBatKendu2(float afBektorea[], int *iLuzera, int iPosizioa) // bi parametroak irterakoak dira
{ // hirugarren parametroa sarrerakoa
int iKont;
for (iKont = iPosizioa; iKont < *iLuzera; iKont++)
{
afBektorea[iKont] = afBektorea[iKont+1];
}
*iLuzera = *iLuzera - 1;
}
Arraytik elementu batzuk kendu haien balioek baldintza bat betetzen dutelako. Adibidez, fMuga baino txikiago diren elementu guztiak kendu arraytik. Elementuak kentzeko edo ezabatzeko ElementuBatzukKendu() funtzioan egingo da, zeinek array laguntzaile bat erabiltzen duen.
/* Ariketa-46f_HainbatElementuKendu: arraytik elementu batzuk kendu
array laguntzaile bat erabiliz */
// Array baten hasieraketa. Datuak dituen array batean, baldintza bat
// betetzen dituzten elementu guztiak kendu.
#include <stdio.h>
#define BEHEMUGA 0.0
#define GOIMUGA 99.9
#define LUZMAX 20 // 20 elementu gehienez: 0. posiziotik 19. posizionarino
void BektoreaIkusi(const float[], int);
void ElementuBatzukKendu(float[], int *, float);
int main()
{
static float afBektorea[LUZMAX] = { 67.34, 2.17, 89.37, 15.08, 6.16, 72.44, 5.09, 38.77, 94.06, 10.10, 22.99 };
int iLuzera = 11;
float fMuga;
printf("\n");
printf("\n\t Arrayaren eta bere luzera efektiboaren hasieraketak");
printf("\n\t ---------------------------------------------------\n");
printf("\n\t Arrayaren iLuzera=%d elementuak hasieraketa ondoren: \n", iLuzera);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
do
{
printf(" 0.0 eta 99.9 arteko muga bat eman (biak barne)\n eta txikiagoan diren elementuak kenduko dira: ");
scanf("%f", &fMuga);
} while (fMuga < 0.0 || fMuga >= 100.0);
ElementuBatzukKendu(afBektorea, &iLuzera, fMuga);
printf("\n\t %.2f baino txikiagoak kendu ondoren: \n", fMuga);
BektoreaIkusi(afBektorea, iLuzera);
printf("\n");
return 0;
}
void BektoreaIkusi(const float afBektorea[], int iLuzera) // bi parametroak sarrerakoak
{
int iKont;
// afBektorea[3] = 3.33; babestuta dago
printf("\n");
printf("\t Posizioa Balioa\n");
printf("\t -------- ------\n");
for (iKont=0; iKont < iLuzera; iKont++)
{
printf("\t %9d %13.2f\n", iKont, afBektorea[iKont]);
}
}
void ElementuBatzukKendu(float afBektorea[], int *iLuzera, float fMuga) // bi parametroak irterakoak dira
{ // hirugarren parametroa sarrerakoa
int iKont;
float afLaguntzailea[LUZMAX];
int iNonGorde;
int iZenbatElementu;
// afBektorea[] arraytik abiatuta afLaguntzailea[] arraya kargatu
iNonGorde = -1; // afLaguntzailea[] hasieran hutsik
iZenbatElementu = 0; // afLaguntzailea[] hasieran hutsik
for (iKont = 0; iKont < *iLuzera; iKont++)
{
if (afBektorea[iKont] >= fMuga) // txikiak saltatu
{
iNonGorde++;
afLaguntzailea[iNonGorde] = afBektorea[iKont];
}
}
iZenbatElementu = iNonGorde + 1;
printf("\n\t Array laguntzailea: (iZenbatElementu=%d) \n", iZenbatElementu);
BektoreaIkusi(afLaguntzailea, iZenbatElementu);
// afLaguntzailea[] arraytik abiatuta afBektorea[] arraya kargatu
for (iKont = 0; iKont < iZenbatElementu; iKont++)
{
afBektorea[iKont] = afLaguntzailea[iKont];
}
// luzera efektiboa eguneratu
*iLuzera = iZenbatElementu;
}
|
iruzkinik ez:
Argitaratu iruzkina