Material de estudo para arquivo sequencial e arquivo indexado

[Klash1 0]

Eae galera!

 

 

Peguei DP na matéria de algoritmos e estou fazendo ela sem frequência, ou seja, preciso estudar por conta própria e ir bem nas provas.

Em fim, vou ter uma prova de arquivos sequenciais e arquivos indexados, porém, o material que tenho do ano passado, está meio confuso, então não sei se está certo.

Vocês poderiam me indicar sites, apostilas, livros, que tenha algoritmos e explicações dessa matéria, aonde tenha a busca binária, inclusão, exclusão e leitura dos arquivos sequencias e indexados?

 

Gostaria que vissem se está correto esses algoritmos:

 

Busca binária:

 

i == 0;

f == final;

m == (i + f) / 2;

         Leia cod;

         Enquanto ((i <= f) e (cod != cliente[m][0]))

         Faça {

                    Se (cod < cliente[m][0]){

                          Então {f  == m - 1;

                    Senão {i == m + 1;     

                                m == (i + f) / 2;

              Se (i <= f)

                   Então {Imprima cliente[m][i];

              Senão imprima "Código não existe";

}

 

 

 

Se não me engano, esse é a inclusão sequencial:

 

i == 0; j == 0; k == 0;


     Enquanto (i < 12 e j < 4)

                        Faça {

                                  Se (s[i][0] < t[j][0])

                                        Então a[k][0] == s[i][0];

                                  i++;

                                  Senão a[k][0] == t[j][0];

                                  j++;

                       k++;

}

                                Se  ( i = 12 )

                                      Então Enquanto (j < 4)

                                                 Faça a[k][0] == t[j][0];

                                                          k++;

                                                          j++;

                                      Senão Enquanto (i < 12)

                                                  Faça a[k][0] == t[j][0];

                                                           k++;

                                                           i++;

}

 

 

 

Exclusão de registros sequenciais:

       Enquanto (j < 4)

                                          Faça

                                                    Se (s[i][0] != t[j][0])

                                                         Então a[k][0] == s[i][0];

                                                                     k++;

                                                   Senão j++;

                      i++;


Não tenho o resto

 

 

Acredito que esse seja a leitura:

 

i == 0; f == final; m == (i + f) / 2;

                    Leia cod;

                             Enquanto (i <= f) e (cod != indice[m][0])

                                                Faça{

                                                        Se (cod < indice[m][0])

                                                             Então f == m - 1;

                                                       Senão i++;

                                                       m == (i + f) / 2;

}

                               Se ( i <= f)

                                    Então k == indice[m][1];

                                    Imprima dados[k][1];

                             Senão Imprima "Código não existe";

 

 

 

Inclusão arquivo indexado:

 

f == final;

            Leia num;

                     dados[f+1][0] = num;

                     k = f + 1;

            Enquanto ( num < indice[f][0] )

                               indice[f+1][0] = indice [f][0];

                               indice[f+1][1] = indice[f][1];

                              f++;

}

           indice[f+1][0] == num;

           indice[f+1][1] == k;

}

 

 

Leitura de arquivos indexados:

 

i == 0; k == 0; a == 0; f == final;

status == 0;

                       Enquanto (i < final)

                                          Faça k == indice[i][1];

                                                    Se (dados[k][status] = 0)

                                                         Então Imprima dados[k][0];

                           i++;

}

 

 

 

Reorganização de arquivo:

 

i == 0; f == final;

                   Enquanto (i <= final)

                                      Faça {

                                               a == indice[i][1];

                                                  Se (dados[a][status] = 0)

                                                       Então na[dados];

                                              k == indice[j][1];

                                         i++;

                                         j++;

}