C++ Material de estudo para arquivo sequencial e arquivo indexado

[Klash]

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++;

}

 

[Plástico Bolha]

É importante que você refaça os algoritmos, para compreender a lógica de funcionamento deles, se alguém simplesmente te explicar, ou mostrar o código feito, ou se você apenas ler em uma apostila, é possível que na hora da prova o professor faça alguma distorção no algoritmo, ou apresente o exercício em um outro formato, justamente para saber se você compreendeu detalhadamente como ele funciona ou apenas decorou uma receita de bolo. Pegando como exemplo o algoritmo de busca binária:

func Binary_SearchI(vet []int, key int, max int) int  {
	var l int = 0;
	var r int = max-1;
	var mid int;
	for(l <= r) {
		mid = (l+r)/2;
		if(key == vet[mid]){
			return mid;
		} else if(key < vet[mid]) {
			r = mid-1;
		} else {
			l = mid+1;
		}
	}
	return -1;
}

func main()  {
	var vet []int = []int{2,5,8,12,16,23,38,56,72,91};
	var max int = len(vet);
	var key int = 38;
	var pos = Binary_SearchI(vet,key,max);
	fmt.Println("Posicao da chave: ", pos);
}

Deu para perceber que este algoritmo abaixo seria um pseudo-código de um algoritmo de busca binária distorcido, para aceitar uma estrutura 'cliente'.

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";

}

O que pode te ajudar a compreender completamente como a busca binária funciona, seria refazer ele de várias maneiras diferentes, por exemplo, pegue o busca binária original/padrão e altere ele para buscar o CPF de um array (do tipo cliente) de clientes como esta por exemplo:

type Client struct {
	CPF int
	Name int
	Login int
	Password int
}
// ...
var Clients [10]Client;
//...
// Acessar o CPF do cliente 0 -> Clients[0][0] 
// ...