Buscar

REVISAOBASICAPROG2P4

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

int compara(int v1,int v2){
	if (v1>v2)
		return 1;
	else
		if(v2>v1)
			return -1;
		else
			return 0;
}
ORDENAÇÃO POR SELEÇÃO
ORDEM CRESCENTE
int escolhe_menor(tipo *v,int in, int n) // escolhe_maior(tipo *v, int ult)
{
	int pm=in,i; 				//pM=0;
	for (i=0;i<n;i++){			//for(i=0;i<=ult;i++)
		if (v[i]<v[pm])				//if(v[i]>v[pM])
			pm=i;					 //pM=i;
	}
	return pm;				//return pM;
}
void ordenaporselecaoMENOR(int *v,int n)			//MAIOR	
{
	int in,pm;						//int ult,pM;
	Tipo *aux;
	for (in=0; in<n;in++)					//for(ult=n-1;ult>0; ult--)
	{
		pm=escolhe_menor(v,in,n); 			//pM=escolhe_maior(v,ult)
		if (pm!=in)					//if(pM!=ult)
		{
			aux=v[in];					.
			v[in]=v[pm];					.
			v[pm]=aux;					.
		}
	}
	return;
}
ORDENAÇÃO POR BOLHA
void bolha(Tipo *v,int n)
{
	int in,troca,fim;
	Tipo *aux;
	for (fim=n-1; fim>0; fim=troca)
	{
		troca=0;
		for(in=0; in<fim;in++)
		{
			if (v[in]>v[in+1])
			{
				aux=v[in];
				v[in]=v[in+1];
				v[in+1]=aux;
				troca=in;
			}
		}
	}
}
BUSCA BINÁRIA
int bb (int *v,int n,int info)
{
	int in=0,fim=n-1,meio;
	while(in<=fim)
	{
		meio=(in+fim)/2;
		if (info<v[meio])
			fim=meio-1;
		else
			if(info>v[meio])
				in=meio+1;
			else
				return meio;
	}
	return -1;
}
		
LISTA ENCADEADA
typedef struct elem Elem;
struct elem {
	int info;
	Elem *prox;
};
Elem *lst_cria(void)
{
	return NULL;
}
Elem *lst_insere(Elem *prim, int info)
{
	Elem *p=(Elem *) malloc (sizeof(Elem));
	if(!p)	return prim;
	p->info=info;
	p->prox=prim;
	return p;
}
void lst_imprime(Elem *prim)
{
	Elem *p;
	for (p=prim; p!=NULL; p=p->prox)
		printf("%d",p->info);
}
int lst_vazia(Elem *prim)
{
	return (prim==NULL);
}
Elem* busca(Elem *prim, int info)
{
	Elem* p;
	for (p=prim; p!=NULL; p=p->prox)
		if(p->info==info)
			return p;
	return NULL;
}
Elem* retira(Elem *prim, int info) //devolve a lista sem o elem
{
	Elem *p,*a;
	for (a=NULL,p=prim; p!=NULL && p->info!=info; a=p,p=p->prox);
	if (p==NULL) //não encontrou o elem
		return prim;
	if (a==NULL) // se o elem é o prim
		prim=p->prox;
	else
		ant->prox=p->prox;
	free(p);
	return prim;
}
void lst_libera(Elem *prim)
{
	Elem *q,*p=prim;
	while(lst_vazia(prim)==0 ou p!=NULL)
	{
		q=p->prox;
		free(p);
		p=q;
	}
	return;
}
Elem* insere_ord(Elem *prim, int info) //ordem crescente
{
	Elem *a,*p,*novo=(Elem *) malloc (sizeof(Elem));
	if (!novo)	return prim;
	for (a=NULL,p=prim; p!=NULL && p->info<info; p=p->prox);
	novo->info=info;
	if (a==NULL) // se é o prim
	{
		novo->prox=prim;
		prim=novo;
	}
	else
	{
		novo->prox=ant->prox;
		ant->prox=novo;
	}
	return prim;
}	
PILHA #insere no final e retira do final
VETOR
#define MAX 50
stuct pilha{
	int info[MAX];
	int topo; //prim pos livre do vetor
};
typedef struct pilha Pilha;
Pilha * pilha_cria(void)
{
	Pilha *pi=(Pilha *) malloc(sizeof(Pilha));
	if (!pi) exit(1);
	pi->topo=0;
	return pi;
}
void pilha_push(Pilha *pi, int info)
{
	if (pi->topo==MAX)
		exit(1);
	pi->info[pi->topo]=info;
	pi->topo++;
}
int pilha_pop(Pilha *pi)
{
	int info;	
	if (pilha_vazia(pi)==1)
		exit(1);
	info=pi->info[pi->topo-1];
	pi->topo--;
	return info;
}
int pilha_vazia(Pilha *pi)
{
	return (pi->topo==0);
}
void pilha_libera(Pilha *pi)
{
	free(pi);
}
LISTA ENC
typedef struct elem Elem;
struct elem {
	int info;
	Elem *prox;
};
stuct pilha{
	Elem *topo; //aponta para o topo da pilha 
};
typedef struct pilha Pilha;
Pilha * pilha_cria(void)
{
	Pilha *pi=(Pilha *) malloc(sizeof(Pilha));
	if (!pi)	exit(1);
	pi->topo=NULL;
	return pi;
}
void pilha_push(Pilha *pi, int info)
{
	Elem *el=(Elem *) malloc (sizeof(Elem));
	if (!el)	exit(1);
	el->info=info;
	el->prox=pi->topo;
	pi->topo=el;
	return;
}
int pilha_pop(Pilha *pi)
{
	int info;
	Elem *aux;	
	if (pilha_vazia(pi)==1)
		exit(1);
	aux=pi->topo;
	info=aux->info;
	pi->topo=aux->prox;
	free(aux);
	return info;	
}
int pilha_vazia(Pilha *pi)
{
	return (pi->prim==NULL);
}
void pilha_libera(Pilha *pi)
{
	Elem *q,*p=pi->prim;
	While(pilha_vazia(pi)!=1)
	{
		q=p->prox;
		free(p);
		p=q;
	}
	free(pi);
}
FILAS //insere no fim e retira no inicio -- ORDEM
LISTA ENCADEADA
typedef struct elem Elem;
struct elem {
	int info;
	Elem *prox;
};
struct fila{
	Elem *in;
	Elem *fim;
};
typedef struct fila Fila;
Fila * fiCria(void)
{
	Fila *fi=(Fila *) malloc (sizeof(Fila));
	if (!fi)	exit(1);
	fi->in=fi->fim=NULL;
	return fi;
}
void fiInsere(Fila *fi,int info)
{
	Elem *el=(Elem *) malloc (sizeof(Elem));
	if (!el)	exit(1);
	el->info=info;
	el->prox=NULL;
	if (fiVazia(fi)==1)
		fi->in=el;
	else
		fi->fim->prox=el;
	fi->fim=el;
	return;
}
int fiRetira(Fila *fi)	
{
	int info;	
	Elem *el;
	if (fiVazia(fi)==1)
		exit(1);
	el=fi->in;
	info=el->info;
	fi->in=el->prox;
	free(el);
	return info;
}
int fiVazia(Fila *fi)
{
	return (fi->in==NULL);
}
void fiLibera(Fila *fi)
{
	Elem *q,*p=fi->in;
	While(fiVazia(fi)!=1)
	{
		q=p->prox;
		free(p);
		p=q;
	}
	free(fi);
}
VETOR
#define N 50
struct fila {
	int n;			/quant de elem na fila
	int in; 		/inicio da fila -- onde é retirado
	int fim;		/fim da fila -- onde é inserido
	int v[N];		
};
typedef struct fila Fila;
Fila * fiCria(void)
{
	Fila *fi=(Fila *) malloc (sizeof(Fila));
	if (!fi)	exit(1);
	fi->n=0;
	fi->in=0;
	fi->fim=-1;
	return fi;
}
Fila *fiInsere(Fila *fi,int info)
{
	if (fi->n==N)		 //fila cheia?
		exit(1);
	fi->fim=(fi->fim+1)%N;
	fi->v[fi->fim]=info;
	fi->n++;
	return fi;
}
int fiRetira(Fila *fi)
{
	int info;	
	if (fiVazia(fi)==1)
		exit(1);
	info=fi->v[fi->in];
	fi->in=(fi->in+1)%N;
	fi->n--;
	return info;
}
int fiVazia(Fila *fi)
{
	return (n==0);
}
void fiLibera(Fila *fi)
{
	free(fi);
}

Teste o Premium para desbloquear

Aproveite todos os benefícios por 3 dias sem pagar! 😉
Já tem cadastro?

Outros materiais