C Arvore binaria e arquivos .txt, linguagem C

[MataMosquito]

Alguém por favor pode me ajudar? Meu professor passou essa questão sobre arquivo .txt e eu não aprendi bem como utiliza ele, eu tenho ate 23:59 de hoje (dia 04/07) pra entregar, será que alguém poderia, pelo menos fazer uma parte para eu ver se entendo?
Está difícil aula online, tem professor que não explica muito bem...

 

4) Num sistema de arquivos.txt (Diretório informado pelo usuário), um catálogo de todos os arquivos é organizado como uma árvore de busca binária AVL. Cada nó denota um arquivo e especifica seu nome e a data de seu último acesso, codificada como um inteiro. Obs: A Data de Acesso devem estar informados dento do arquivo. A data deve estar formata em DD/MM/YYYY.

 

a. Escreva um programa que percorra a árvore e apague todos os arquivos cujos últimos acessos tenham sido anteriores a uma certa data informada pelo usuário. As chaves do catálogo são os nomes dos arquivos.

 

b. O programa também deverá permitir consultar os arquivos presentes na lista

[arfneto]

Você já escreveu código para tratar essas árvores antes?  AVL é difícil de manter balanceada, tem o lance da rotação dos ponteiros quando apaga registros, e é exatamente o que vai fazer aqui.

 

Se já tem o código apenas mude uma função de percurso e ao encontrar um arquivo a excluir apague o nó e reorganize a árvore.

Isso nada tem a ver com arquivos txt. Talvez devesse mudar o título para algo como "Apagando registros de árvores AVL"

[MataMosquito]

Então no caso eu devo simular que cada nó da arvore fosse um arquivo e guardar no nó as informação de data né?
eu sei que é pedir muito mas tem como você fazer só esse pra min? é 7 no total e eu já fiz 5 só falta essa e a 5 que eu estou fazendo agora.

eu tenho um codigo de AVL que o prof mandou

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>
#include<locale.h>
#include<string.h>
typedef struct Nodo* Arvore;

struct Nodo{
	int info;
	int alt;
	struct Nodo *esq;
	struct Nodo *dir;
};

Arvore* CriarArvore(){
	Arvore* raiz = (Arvore*) malloc(sizeof(Arvore));
	
	if(raiz != NULL){
		
		*raiz = NULL;
	}return raiz;
}

void LiberaNodo(struct Nodo* nodo){
	if(nodo != NULL){
		
		LiberaNodo(nodo->esq);
		LiberaNodo(nodo->dir);
		free(nodo);
		nodo = NULL;
	}
}

void LiberaArvore(Arvore *raiz){
	
	if(raiz != NULL){
		LiberaNodo(*raiz);
		free(raiz);
	}
}

int ArvoreEstaVazia(Arvore *raiz){
	int retorno = 0;
	
	if(raiz == NULL){
		retorno = 1;
		
	}else if(*raiz ==NULL){
		retorno = 1;
		
	}
	return retorno;
}

int ArvoreAltura(Arvore *raiz){
	
	int retorno = 0;
	
	if(raiz != NULL && *raiz != NULL){
		
		int alt_esq = ArvoreAltura(&((*raiz)->esq));
		int alt_dir = ArvoreAltura(&((*raiz)->dir));
		
		if(alt_esq>alt_dir){
			
			retorno = alt_esq + 1;
		}else{
			
			retorno = alt_dir + 1;
		}
	}
}

int TotalNodoArvore(Arvore *raiz){
	
	int retorno = 0;
	
	if(raiz != NULL && *raiz != NULL){
		
		int alt_esq = ArvoreAltura(&((*raiz)->esq));
		int alt_dir = ArvoreAltura(&((*raiz)->dir));
		retorno = alt_esq + alt_dir + 1;
	}
}

void ListarArvore(Arvore *raiz){
	
	int retorno = 0;
	
	if(raiz != NULL && *raiz != NULL){
		
		printf("%i \n", (*raiz)->info);
		ListarArvore(&((*raiz)->esq));
		ListarArvore(&((*raiz)->dir));
	}
}

int AlturaNodo(struct Nodo* nodo){
	
	int altura = -1;
	
	if(nodo != NULL){
		
		altura = nodo->alt;
	}
	return altura;
}

int FatorBalanceamento(struct Nodo *nodo){
	
	return labs(AlturaNodo(nodo->esq) - AlturaNodo(nodo->dir));
}

int Maior(int x, int y){
	
	int retorno = x;
	
	if(y > x){
		retorno = y;
	}
	return retorno;
}

void RotacaoLL(Arvore *raiz){
	
	struct Nodo *nodo;
	nodo = (*raiz)->esq;
	(*raiz)->esq = nodo->dir;
	nodo->dir = (*raiz);
	
	(*raiz)->alt = Maior(AlturaNodo((*raiz)->esq), AlturaNodo((*raiz)->dir)) + 1;
	nodo->alt = Maior(AlturaNodo(nodo->esq), (*raiz)->alt) + 1;
	(*raiz) = nodo;
}

void RotacaoRR(Arvore *raiz){
	
	struct Nodo *nodo;
	nodo = (*raiz)->dir;
	(*raiz)->dir = nodo->esq;
	nodo->esq = (*raiz);
	
	(*raiz)->alt = Maior(AlturaNodo((*raiz)->esq), AlturaNodo((*raiz)->dir)) + 1;
	nodo->alt = Maior(AlturaNodo(nodo->esq), (*raiz)->alt) + 1;
	(*raiz) = nodo;
}

void RotacaoRL(Arvore *raiz){
	
	RotacaoLL(&(*raiz)->dir);
	RotacaoRR(raiz);
}

void RotacaoLR(Arvore *raiz){
	
	RotacaoLL(&(*raiz)->esq);
	RotacaoRR(raiz);
}

void InsereArvoreAVL(Arvore *raiz, struct Nodo *novo){
	
	if(*raiz == NULL){
		
		novo->alt = 0;
		*raiz = novo;
	}else{
		
		struct Nodo *atual = *raiz;
		
		if(novo->info < atual->info){
			
			InsereArvoreAVL(&(atual->esq), novo);
			
			if(FatorBalanceamento(atual) >= 2){
				
				if(novo->info < (*raiz)->esq->info){
					
					RotacaoLL(raiz);
				}else{
					
					RotacaoLR(raiz);
				}
			}
		}else if(novo->info > atual->info){
			
			InsereArvoreAVL(&(atual->dir), novo);
			
			if(FatorBalanceamento(atual) >= 2){
				
				if((*raiz)->dir->info < novo->info){
					
					RotacaoRR(raiz);
				}else{
					
					RotacaoRL(raiz);
				}
			}
		}
		
		atual->alt = Maior(AlturaNodo(atual->esq), AlturaNodo(atual->dir))+ 1;
	}
}

void InsereArvore(Arvore *raiz){
	
	int retorno = 0;
	
	if(raiz != NULL){
		
		int valor = 0;
		printf("informe o Número\n");
		scanf ("%i", &valor);
		
		struct Nodo* novo = (struct Nodo*)malloc(sizeof(struct Nodo));
		novo->info = valor;
		novo->esq = NULL;
		novo->dir = NULL;
		
		InsereArvoreAVL(raiz, novo);
	}
}

struct Nodo *ProcuraMenor(struct Nodo *atual){
	
	struct Nodo* nodo1 = atual;
	struct Nodo* nodo2 = atual->esq;
	
	while(nodo2 != NULL){
		
		nodo1 = nodo2;
		nodo1 = nodo2->esq;
	}
	return nodo1;
}

int RemoveNodoArvoreAVL(Arvore *raiz, int valor){
	
	int res = 0;
	
	if(valor < (*raiz)->info){
		
		if(res = RemoveNodoArvoreAVL(&(*raiz)->esq, valor) == 1){
			
			if(FatorBalanceamento(*raiz) >= 2){
				
				if(AlturaNodo((*raiz)->dir->esq) <= AlturaNodo((*raiz)->dir->dir)){
					
					RotacaoRR(raiz);
				}else{
					
					RotacaoRL(raiz);
				}
			}
		}
	}else if(valor > (*raiz)->info){
		
		if(res = RemoveNodoArvoreAVL(&(*raiz)->dir, valor) == 1){
			
			if(FatorBalanceamento(*raiz) >= 2){
				
				if(AlturaNodo((*raiz)->esq->dir) <= AlturaNodo((*raiz)->esq->esq)){
					
					RotacaoLL(raiz);
				}else{
					
					RotacaoLR(raiz);
				}
			}
		}
	}else if(valor == (*raiz)->info){
		
		if(((*raiz)->esq == NULL || (*raiz)->dir == NULL )){
			
			struct Nodo *oldNodo = (*raiz);
			
			if((*raiz)->esq != NULL){
				
				*raiz = (*raiz)->esq;
			}else{
				
				*raiz = (*raiz)->dir;
			}
			free(oldNodo);
		}else{
			
			struct Nodo *temp = ProcuraMenor((*raiz)->dir);
			
			(*raiz)->info = temp->info;
			
			RemoveNodoArvoreAVL(&(*raiz)->dir, (*raiz)->info);
			
			if(FatorBalanceamento(*raiz) >= 2){
				
				if(AlturaNodo((*raiz)->esq->dir) <= AlturaNodo((*raiz)->esq->esq)){
					
					RotacaoLL(raiz);
				}else{
					
					RotacaoLR(raiz);
				}
			}
		}
		res = 1;
	}
	return res;
}

void RemoveArvore(Arvore *raiz){
	
	int retorno = 0;
	
	if(raiz != NULL){
		
		int valor = 0;
		printf("informe o Número a Deletar\n");
		scanf("%i", &valor);
		
		RemoveNodoArvoreAVL(raiz, valor);
	}
}

void ConsultaArvore(Arvore *raiz){
	if(raiz != NULL){
		int valor = 0;
		printf("informe um Número\n");
		scanf("%i", &valor);
		
		if(raiz != NULL){
			struct Nodo* atual = *raiz;
			int alturaValor = 1;
			bool registroEncontrado = false;
			while(atual != NULL){
				if(valor == atual->info){
					printf("Registro encontrado na altura %i\n", alturaValor);
					registroEncontrado = true;
					break;
				}else if(valor >= atual->info){
					alturaValor = alturaValor +1;
					atual = atual->dir;
				}else {
					alturaValor = alturaValor +1;
					atual = atual->esq;
				}
			}
			if(registroEncontrado == false){
				printf("Registro não encontrado\n");
			}
		}
	}
}

int main (void){
	setlocale(LC_ALL, "Portuguese");
	
	bool sair = false;
	int opcao = 0;
	Arvore *raiz = CriarArvore();
	int altura = 0;
	int nodo = 0;
	
	do{
		system("cls");
		printf("******************************************************\n");
		printf("***********************MENU***************************\n");
		printf("******************************************************\n");
		printf("1 - Inserir\n");
		printf("2 - Deletar\n");
		printf("3 - Listar\n");
		printf("4 - Consultar\n");
		printf("5 - Altura Arvore\n");
		printf("6 - Nodos Arvore\n");
		printf("7 - sair\n");
		scanf("%i", &opcao);
		fflush(stdin);
		
		switch(opcao){
			case 1:
				InsereArvore(raiz);
				break;
			case 2:
				RemoveArvore(raiz);
				break;
			case 3:
				ListarArvore(raiz);
				break;
			case 4:
				ConsultaArvore(raiz);
				break;
			case 5:
				altura = ArvoreAltura(raiz);
				printf("Altura total da Arvore %i\n", altura);
				system("PAUSE");
				break;
			case 6:
				nodo = TotalNodoArvore(raiz);
				printf("Nodos total da Arvore %i\n", nodo);
				system("PAUSE");
				break;
			default:
				sair = true;
				break;
		}
	}
	while(sair == false);
	LiberaArvore(raiz);
	printf("\n");
	system("pause");
	return (0);
}

 

[arfneto]

1 hora atrás, MataMosquito disse:

Então no caso eu devo simular que cada nó da arvore fosse um arquivo e guardar no nó as informação de data né?
eu sei que é pedir muito mas tem como você fazer só esse pra min? é 7 no total e eu já fiz 5 só falta essa e a 5 que eu estou fazendo agora

 

Não, não precisa. Os nomes dos arquivos e a data de último acesso são apenas os dados em cada nó.

 

Só que tem o lance do conteúdo do arquivo ter a data de acesso

 

6 horas atrás, MataMosquito disse:

A Data de Acesso devem estar informados dento do arquivo. A data deve estar formata em DD/MM/YYYY.

 

Imagino que não seja então para usar a data de último acesso ao arquivo, a data que é mantida pelo sistema, e sim usar essas "datas" aí.

 

Então é uma ideia meio b3st@, mas seria o caso então de:

• criar um diretório com esses arquivos txt
• ao rodar o programa pegar o diretório e a tal data
• ler os arquivos da pasta e
  • pegar a data, que pode ser o único conteúdo do arquivo, e colocar na árvore junto com o nome
• depois pegar a data de exclusão, varrer a árvore e apagar os arquivos usando o critério.
• 3 fases então. 
• Para cria os arquivos pode usar o editor de texto mesmo. Não precisa fazer parte de um programa.

 

Não entendi porque tem 1 menu em seu programa... 

 

Não escreva programas interativos. C nem é pra isso. E seu programa não é pra isso.

 

Use a linha de comando. São dois parâmetros de entrada: a pasta onde estão os arquivos e a data de corte. Nada mais.

 

Se seu programa fosse chamado tst não seria o simples escrever
 

    tst pasta 04072021

e ter o programa entrando no diretório pasta e apagando os arquivos com data de accesso anterior a essa data?

Não há mais perguntas. Apenas o resultado. Pra que um menu, e ficar parado em frente a tela e tal?

 

[MataMosquito]

Obrigado consegui fazer aqui com meus  amigo, obrigado pelas dicas