Módulo 6-Estruturas Dinâmicas(Ponteiros)

 

1-   Conceitos básicos de estruturas dinâmicas:

Um ponteiro ou apontador é um tipo especial de variável que é capaz de receber um endereço de memória RAM relative a um determindo tipo de dados, de forma como que a apontar para ele;

Relativamente as estrutruras dinâmicas que exitem por assim dizer algumas regras para realizar alguns procedimentos:

- Qunto á lista ordenada podemos referir que não existe uma regra se pretender remover dados pois é uma estrutura cujo o utilizador pode escolher o dado a ser removido, logo pode ser qualquer dado da lista;

- Quanto á pilha podemos referir que uma estrutura dinâmica identica a lista mas existe uma pequna regra se pretender remover dados e essa regra é LIFO que quer dizer LAST IN FIRST OUT . Isto em português quer dizer que o ultimo dado a ser introduzido vai ser o primeiro a ser removido;

- Quanto á Fila podemos referir que é uma estrura dinâmica que também tem uma pequena regra para a remoção de dados que é  FIFO que quer dizer FIRST IN FIRST OUT. Isto em português quer dizer que o primeiro dado a ser introduzido vai ser o primeiro dado a ser removido.

2- LISTA ORDENADA

  

Exemplo de uma lista ordenada implementada num programa:

1. Program lista_ordenada;
2. type registo=record
3.    nome:string;
4.    pont:^registo;
5.  end;
6. var pi, px:^registo;
7.  a:char;
8. procedure inserir;
9. begin
10.  new(px);
11.  write('nome:');
12.  readln(px^.nome);
13.  px^.pont:=pi;
14.  pi:=px;
15. end;
16. procedure listar;
17. begin
18.  px:=pi;
19.  if(pi=nil) then
20.   writeln('pilha vazia')
21.  else
22.  begin
23.   while (px<>nil) do
24.   begin
25.    writeln(px^.nome);
26.    px:=px^.pont;
27.   end;
28.  end;
29. end;
30. procedure ordenar;
31. var x, y:^registo;
32.  h:boolean;
33.  aux:string;
34. begin
35.  if (pi=nil) then
36.   write('pilha vazia')
37.  else
38.  begin
39.   if(pi^.pont=nil) then
40.   begin
41.    writeln('so tem um elemento');
42.    writeln(pi^.nome);
43.   end
44.   else
45.    repeat
46.     h:=false;
47.     x:=pi;
48.     y:=pi^.pont;
49.     repeat
50.      if(x^.nome>y^.nome) then
51.      begin
52.       h:=true;
53.       aux:=x^.nome;
54.       x^.nome:=y^.nome;
55.       y^.nome:=aux;
56.      end;
57.      x:=x^.pont;
58.      y:=y^.pont;
59.     until(y=nil);
60.    until(not h);
61.  end;
62. end;
63. procedure eliminar;
64. var z:string;
65.  pa:^registo;
66. begin
67.  pa:=nil;
68.  px:=pi;
69.  if (px=nil) then
70.   writeln('pilha vazia')
71.  else
72.  begin
73.   write('nome a eliminar:');
74.   readln(z);
75.   while ((px<>nil) or (px^.nome<>z)) do
76.   begin
77.    pa:=px;
78.    px:=px^.pont;
79.   end;
80.   if (px=nil) then
81.    writeln('elemento nao existente')
82.   else
83.   if (px=pi) then
84.    pi:=pi^.pont
85.   else
86.    pa^.pont:=px^.pont;
87.   dispose(px);
88.  end;  
89. end;
90. Begin //Programa Principal
91.  pi:=nil;
92.  repeat
93.   writeln('1:inserir');
94.   writeln('2:listar');
95.   writeln('3:eliminar');
96.   writeln('4:ordenar');
97.   writeln('0:sair');  
98.   readln(a);
99.   case a of
100.    '1':inserir;
101.    '2':listar;
102.    '3':eliminar;
103.        '4':ordenar;
104.   end;
105.  until(a='0');
106. end.

Reflexão

Quanto á inserção dos dados numa lista ordenada podemos referir que os dados são inseridos pelo utilizador, e quando mesmo pretende remover não tem uma ordem obrigatória pois na lista ordenada qualquer dado pode ser removido mesmo que esteja na base,meio ou topo. Assim isto pode ser considerado como uma vantagem em relação ás outras estruturas dinâmicas.

3-Pilha 

Exemplos de uma pilha no mundo real:



    Exemplo de uma pilha implementada num programa:

1. Program Pilha;
2. Type Pessoa = record
3.  Nome:string;
4.  Prox:^Pessoa;
5. end;
6. Var  Top, Px:^Pessoa;
7.             Op:Integer;
8. Procedure Insere;
9. Begin
10.             new(Px);
11.             writeln ('Escreva o nome da pessoa');
12.             Readln (Px^.Nome);
13.             Px^.prox:=Top;
14.             Top:=Px;
15. end;
16. Procedure Percorre;
17. Begin
18.             Px:=Top;
19.             If (Px=Nil) Then
20.                         writeln ('Pilha vazia')
21.                         else
22.                         begin
23.                                    Repeat
24.                                                writeln ('Nome:',Px^.Nome);
25.                                                Px:=Px^.Prox;
26.                                    Until (Px=Nil);
27.                         end;
28. end;
29. Procedure Remove;
30. Begin
31.             If Top=Nil then
32.                         writeln ('Pilha vazia')
33.             else
34.             begin
35.                         Px:=Top;
36.                         writeln ('Elemento removido:',Px^.Nome);
37.                         Top:=Px^.Prox;
38.                         Dispose(Px);
39.             end;
40. end;              
41.                                                                                                         
42.  Begin
43.             Top:=Nil;
44.             Repeat
45.                         writeln;
46.                         writeln ('Escolha a operação');
47.                         writeln ('1-inserir');
48.                         writeln ('2-Percorrer');
49.                         writeln ('3-Remover');
50.                         readln (op);
51.                         Case op of
52.                                    1:Insere;
53.                                    2:Percorre;
54.                                    3:Remover;
55.                         end;
56.             until op=0;                 
57.  End.

Reflexão

Na pilha já existe uma ordem de entrada e saida de dados.

Ao contrário da anterior estrutura dinâmica referida esta obedece a uma unica regra para a remoção de dados e essa regra é LIFO(First in First out) ou seja o primeiro dado que foi introduzido pelo utilizador vai ter que ser obrigatoriamente o primeiro sair.

4 - Fila

 Exemplo de uma fila implementada num programa funcionávél:

1. Program fila ;
2. type pessoa=record
3.                 nome:string;
4.                 idade:integer;
5.                 peso:real;
6.                 prox:^pessoa;
7. end;
8. var cauda,frente,px:^pessoa;
9.     x:char;
10.     y:integer;
11.  procedure inserir;
12.  begin
13.                 new(px);
14.                 writeln('Nome:');
15.                 read(px^.nome);
16.                 writeln('Idade:');
17.                 read(px^.idade);
18.                 writeln('Peso:');
19.                 read(px^.peso);
20.                 if frente=nil then
21.                 begin
22.                                frente:=px;
23.                                cauda:=px;
24.                 end
25.                 else
26.                 begin
27.                                cauda^.prox:=px;
28.                                cauda:=px;
29.                                cauda^.prox:=nil;
30.                 end;
31.  end;
32.  procedure percorrer;
33.  begin
34.                 px:=frente;
35.                 if px=nil then
36.                                writeln('Pilha vazia')
37.                 else
38.                 begin
39.                                repeat
40.                                                writeln('Nome: ',px^.nome);
41.                                                writeln('Idade: ',px^.idade);
42.                                                writeln('Peso: ',px^.peso);
43.                                                px:=px^.prox;
44.                                until (px=nil);
45.                 end;
46.  end;
47.  procedure eliminar;
48.  begin
49.                 px:=frente;
50.                 if px=nil then
51.                                writeln('Pilha vazia')
52.                 else
53.                 begin
54.                                px:=frente;
55.                                frente:=frente^.prox;
56.                                dispose(px)
57.                 end;
58.  end;    
59.  Begin
60.       cauda:=nil;
61.       frente:=nil;
62.       repeat
63.                 writeln('1-para inserir dados.');
64.                 writeln('2-para mostrar dados.');
65.                 writeln('3-para eliminar dados.');
66.                 writeln('Qual a opção');
67.                 read(y);
68.                 case y of
69.                                1:inserir;
70.                                2:percorrer;
71.                                3:eliminar;
72.                 end;
73.                                writeln('Deseja continuar?(S-N)');
74.                                read(x);
75.                 until(x='n') or (x='N');   
76.  End.

  Esquema de uma fila:

 

Reflexão

Por fim quanto á fila podemos referir que é uma estrutura dinâmica também com uma regra para a remoção de dados e essa regra é FIFO(First in First out).

Isto quer dizer que o primeiro dado a ser introduzido pelo utilizador vai ser o primeiro a ser removido quando o utilizador o pretender.

Esta estrura pode ser muito util para um centro de saúde pois o primeiro paciente que entre dirige-se ao balcão o seus dados são preenchidos, e como a ordem é a de entrada logo que o primeiro paciente seja atendido os seus dados ja posem ser removidos e assim sucessivamente.

 

Se pretender testar os programas acima apresentados aqui tem um link para fazer download do compilador (Pascal Zim)

 http://www.baixaki.com.br/download/pascal-zim-.htm