tp w 5 Strukturalne typy zmiennych, Ebooks, Informatyka, Pascal, wykłady

[ Pobierz całość w formacie PDF ]
Strukturalne typy zmiennych, pojęcie tablicy, definiowanie typu tablicowego i deklaracja tablic, odwoływanie się do elementów tablicy, inicjowanie zmiennej tablicowej, tablice wielowymiarowe. Typowe operacje na tablicach – wczytywanie z klawiatury, wyświetlanie na ekranie,  wstawianie elementów o wartościach losowych, zamiana elementów, wprowadzanie i usuwanie elementów, znajdowanie lub zliczanie elementów tablicy o zadanych wartościach, znajdowanie wartości maksymalnej i minimalnej, sortowanie.

Tablica składa się z ustalonej liczby elementów tego samego typu, zwanego typem składowym (może być typem prostym, łańcuchowym lub strukturalnym). Za pomocą tablic reprezentowane są regularne układy danych np. wektory, macierze.

Dostęp do poszczególnych elementów tablicy uzyskuje się za pomocą indeksowania. Indeksem może być dowolne wyrażenie, którego wartość jest zgodna w sensie przypisania z typem indeksowym.

Definicja typu tablicowego

              type identyfikator_typu = array [typy_indeksowe] of typ_składowy;

                            gdzie typ indeksowy to typ porządkowy z wyjątkiem LongInt.

Przykłady:

              type wektor = array [0..50] of integer;

              type macierz = array [1..20] of array [1..30] of real;

              type macierz = array [1..20][1..30] of real;

type macierz = array [1..20, 1..30] of real;

type tablica = array [Boolean, 1..20] of char;

type zakres = 10..20;

         tablica = array [zakres] of char;

Uwaga:

W poniższych przykładach przyjęto następującą definicję typu tablicowego:

              const  N = 20;

              type  tab = array[1 .. N]  of integer;

Wprowadzanie elementów  tablicy z klawiatury

              procedure  Czytaj( var A : tab);

              var i : integer;

              begin

                for  i := 1  to  N  do

                   begin

                            write( ‘Podaj ‘, i, ‘ element: ‘);

                            readln( A[i] );

                   end;

              end;

              procedure  Losuj( var A : tab; k : integer);

              var i : integer;

              begin

  randomize;

  for  i := 1 to N do

A[i] := random(k);

              end;

              procedure  Szereg( var A : tab);

              var i : integer;

              begin

                for  i := 1  to  N  do

                            A[i] := 2 * i;                            { liczby parzyste }

              end;

procedure  Pisz( var A : tab; k : integer);

              var i : integer;

              begin

   for i := 1 to N do

                     begin

   write( A[i]:8 );

   if (i mod k)=0 then writeln;

end;

              end;

procedure  Max_Min( var T : tab; var max, min : integer);

              var  i : integer;

              begin

   min := T[1];

   max := T[1];

   for  i:=2 to N do

      begin

if  T[i]>max  then max:=T[i];

if  T[i]<min   then min:=T[i];

      end;

end;

              function  Ile ( var  A : tab; klucz : integer ) : integer;

              var  i, k : integer;

              begin

                 k := 0;

                 for  i := 1  to  N  do

                            if  A[i] = klucz then k := k+1;

                 Ile := k;

              end;

              function  Gdzie ( var  A : tab; klucz : integer ) : integer;

              var  i : integer;

              begin

                 i := 0;

                 repeat

                   i := i+1;

                 until  ( A[i]= klucz )  or ( i=N );

                 if  A[i] = klucz then  Gdzie := i

                                              else   Gdzie := 0;

              end;

procedure Sort( var X : tab);

var   i, k : integer;

        t: : integer;

begin

   for  k := N-1 downto 1 do

     for  i:=1 to k do

              if X[i]>X[i+1] then

                 begin

                            t:=X[i];

                            X[i]:=X[i+1];

                            X[i+1]:=t;

                 end;

end;              {Sort}