Ir ao conteúdo
  • Cadastre-se
Klash

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

Recommended Posts

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

}

 

  • Amei 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

É 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] 
// ...
 

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×