gistfile1.txt

Alocação dinamica de memória


// 01.c

int *p, *q; // declara 2 ponteiros p e q
p = malloc (sizeof (int)); //aloca para p  o tamanho  de um inteiro
*p = 123;        // ponteiro p aponta para 123;
q = malloc (sizeof (int));
*q = *p;    //aloca para q o tamanho  de um inteiro
q = p;  // q recebe o valor de p
free (p); //libera a memoria alocada para p
free (q); // libera o memoria porem o valor ira ficar perdido
q = NULL; // apaga o valor da variavel

 

 

//
//  02.c
//  AulaEPO
//

#include <stdio.h>
#include <stdlib.h>

char *CPS(char c) {
    char *a = NULL;
    
    a = (char *)malloc(2*sizeof(char));

    a[0] = c;
    a[1] = '\0';
    
    /*Devolve o endereço do vetor alocado (string). */
    return a;
}

int main() {
    char *S;
    char c;
    
    printf("Digite um caracter: ");
    scanf("%c",&c);
    
    /*S recebe o endereço do vetor alocado.*/
    S = CPS(c);
    printf("Saída: %s\n", S);
    
    /*Libera a memória que foi alocada na função.*/
    free(S);
    
    return 0;
}

 

//
//  03.c
//  AulaEPO
//

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n, i, num;
    int *vet = NULL;
    
    /*recebe o tamanho do vetor*/
    printf("Tamanho do vetor: \n");
    scanf("%d",&n);
    
    /*aloca um vetor com n inteiros que fica armazenado no ponteiro *vet*/
    vet = (int *)malloc(n*sizeof(int));
    
    printf("Valores do vetor: \n");
    for(i = 0; i < n; i++) {
        scanf("%d", &num);
        vet[i] = num;
    }
    
    /*Imprime o vetor em ordem invertida.*/
    for (i = n-1; i >= 0; i--) {
        printf(" %d ",vet[i]);
    }
    printf("\n");
    
    /*Libera a memória alocada do vetor.*/
    free(vet);
    
    return 0;
}

gistfile2.txt

Lista Encadeada

//
//  listaEncadeada.c
//  AulaEPO
//

#include <stdlib.h>
#include <stdio.h>

struct cel {
    int         conteudo;
    struct cel *prox;
};

typedef struct cel celula;  // célula

void imprima( celula *ini) {
}

celula *busca (int x, celula *ini) {
    celula *p;
    p = ini->prox;
    while (p != NULL && p->conteudo != x)
        p = p->prox;
    return p;
}

void insere (int x, celula *p) {
    celula *nova;
    nova = malloc (sizeof (celula));
    nova->conteudo = x;
    nova->prox = p->prox;
    p->prox = nova;
}

void remover(celula *p) {
    celula *morta;
    morta = p->prox;
    p->prox = morta->prox;
    free (morta);
}

void buscaERemove (int y, celula *ini) {
    celula *p, *q;
    p = ini;
    q = ini->prox;
    while (q != NULL && q->conteudo != y) {
        p = q;
        q = q->prox;
    }
    if (q != NULL) {
        p->prox = q->prox;
        free (q);
    }
}

void buscaEInsere (int x, int y, celula *ini) {
    celula *p, *q, *nova;
    nova = malloc (sizeof (celula));
    nova->conteudo = x;
    p = ini;
    q = ini->prox;
    while (q != NULL && q->conteudo != y) {
        p = q;
        q = q->prox;
    }
    nova->prox = q;
    p->prox = nova;
}

void main (void) {
    celula lista1;
    lista1.prox = NULL;
    insere(1, &lista1);
    insere(2, &lista1);
    insere(3, &lista1);
    insere(4, &lista1);
    insere(5, &lista1);
    insere(6, &lista1);
    imprima(&lista1);
    printf("\n");
    printf("%d\n", (busca(5, &lista1))->conteudo);
    buscaEInsere(10,3, &lista1);
    imprima(&lista1);
    printf("\n");
    buscaERemove(10, &lista1);
    imprima(&lista1);
    printf("\n");
}

gistfile3.txt

Duplamente encadeada

//
//  main.cpp
//  duplamenteEncadeada
//
//  Created by Muto on 12/11/15.
//  Copyright © 2015 Leandro Muto. All rights reserved.
//

#include <stdlib.h>
#include <stdio.h>

typedef struct cel {
	int conteudo;
	struct cel *ant;
	struct cel *prox;
} celula;

celula* inicia() { //OK
	celula *cabeca;
	cabeca = (celula *) malloc(sizeof(celula));
	
	cabeca->prox = nullptr;
	cabeca->ant = nullptr;
	
	return cabeca;
}

celula* insere(celula *ini, int cont) { // inserir no começo da lista - OK
	celula *nova;
	nova = (celula *) malloc(sizeof(celula));
	
	if(!nova){
		printf("Falta de memória.");
		exit(0);
	}
	
	nova->prox = ini->prox; // nova->prox = NULL
	
	nova->ant = ini;
	
	nova->conteudo = cont; // conteudo da nova celula
	
	if(ini->prox == nullptr) {
		ini->prox = nova;
	}
	else {
		ini->prox->ant = nova;
	}
	ini->prox = nova;
	
	return nova;
}

void remover(celula *ini, int cont) { // OK
	celula *aux;
	
	for(aux = ini->prox; aux != nullptr; aux = aux->prox) {
		if(aux->prox == nullptr and aux->conteudo == cont) {
			printf("Removido conteúdo %d.\n", aux->conteudo);
			aux->ant->prox = aux->prox;
			free(aux);
		}
		else if(aux->conteudo == cont){
			aux->prox->ant = aux->ant;
			aux->ant->prox = aux->prox;
			printf("Removido conteúdo %d.\n", aux->conteudo);
			free(aux);
		}
	}
}

void imprime(celula *ini) { // OK
	celula *aux;
	
	if(ini->prox == nullptr) {
		printf("Lista vazia.\n");
	}
	else {
		printf("[");
		for(aux = ini->prox; aux != nullptr; aux = aux->prox) {
			if(aux->prox == nullptr) {
				printf(" [%d | %d | NULL] ", aux->ant, aux->conteudo);
			}
			else {
				printf(" [%d | %d | %d] -> ", aux->ant, aux->conteudo, aux->prox);
			}
		}
		printf("]\n");
	}
}

celula *busca(celula *ini, int val) { // OK
	celula *aux;

	for(aux = ini; aux != nullptr; aux = aux->prox) {
		if(aux->conteudo == val) {
			printf("Número %d encontrado na lista.\n", aux->conteudo);
			return aux;
		}
	}
	printf("Não foi encontrado o número %d.\n", val);
	return nullptr;
}

void buscaRemove(celula *ini, int cont) { // OK
	celula *aux = busca(ini, cont);
	
	if(aux == nullptr) {
		exit(0);
	}
	else if(aux->prox == nullptr){
		aux->ant->prox = nullptr;
		printf("Última célula com conteúdo %d removida.\n", aux->conteudo);
		free(aux);
	}
	else {
		aux->prox->ant = aux->ant; //próximo aponta pra anterior
		aux->ant->prox = aux->prox; // anterior aponta pro próximo
		printf("Conteúdo %d removido.\n", aux->conteudo);
		free(aux);
	}
	
}

void buscaEInsere (celula *ini, int contPesquisar, int contInserir) {
	celula *nova, *aux;
	nova = (celula *) malloc(sizeof(celula));
	nova->conteudo = contInserir;
	
	aux = busca(ini, contPesquisar);
	
	if(aux == nullptr) {
		insere(ini, contInserir);
	}
	else {
		nova->ant = aux->ant;
		nova->prox = aux;
		aux->ant->prox = nova;
		aux->ant = nova;
		
	}
}

int main (void) {
	celula* ini;
	ini = inicia();
	
	insere(ini, 1);
	insere(ini, 2);
	insere(ini, 3);
	insere(ini, 4);
	
	imprime(ini);
	
	remover(ini, 1);
	
	imprime(ini);
	
	buscaEInsere(ini, 3, 2);
	
	imprime(ini);

}

gistfile4.txt

Pilha com lista simplesmente encadeada

/
//  pilhaEncadeada.cpp
//  duplamenteEncadeada
//
// Você deve implementar uma pilha, utilizando a estrutura da lista simplesmente encadeada,
// e um programa main que insira alguns números na pilha e os remova a partir de comandos
// entrados no teclado pelo usuário.

// Este programa deve ser implementado de forma que a manutenção seja fácil, ou seja, se
// for decidido pela troca da estrutura de dados que implementa a pilha, nenhuma alteração
// no programa main deve ser necessária.

#include <stdio.h>
#include <stdlib.h>

typedef struct cel {
    struct cel *prox;
    int conteudo;
} celula;

cel *inicia() { //OK
    celula *cabeca;
    cabeca = (celula *) malloc(sizeof(celula));
    
    cabeca->prox = nullptr;
    cabeca->conteudo = 0;
    
    return cabeca;
}

celula *insere(cel *ini, int cont) {
    celula *nova;
    nova = (celula *) malloc(sizeof(celula));
    nova->conteudo = cont;
    
    celula *aux = ini->prox;
    
    if(!nova) {
        printf("Falta de memória.\n");
        return nullptr;
    }
    
    if(aux == nullptr) {
        nova->prox = ini->prox;
        ini->prox = nova;
        printf("Valor %d inserido na pilha.\n", cont);
    }
    else {
        nova->prox = aux;
        ini->prox = nova;
        printf("Valor %d inserido no início pilha.\n", cont);
    }
    return nova;
}

void imprime(cel *ini) {
    celula *aux = ini->prox;
    
    if(ini->prox == nullptr) {
        printf("Pilha vazia.\n");
        exit(0);
    }

    while(aux != nullptr) {
        if(aux->prox == nullptr) {
            printf(" [ %d | NULL ]\n\n", aux->conteudo);
        }
        else {
            printf(" [ %d | %d ]\n\u0009   |\n\u0009   v\n", aux->conteudo, aux->prox);
        }
        aux = aux->prox;
    }
}

void remove(cel *ini) {

    celula *aux = ini->prox;
    
    if(aux == nullptr) {
        printf("Pilha vazia.\n");
    }
    else {
        ini->prox = ini->prox->prox;
    
        printf("Valor %d removido da pilha.\n", aux->conteudo);
        free(aux);
    }
}

int main() {
    celula *ini = inicia();
    int opc = 0;
    
    while(opc != 9) {
        printf("_____________________\n");
        printf("|Escolha uma opção: |\n");
        printf("_____________________\n");
        printf("| 1 - Inserir       |\n");
        printf("_____________________\n");
        printf("| 2 - Imprimir       |\n");
        printf("_____________________\n");
        printf("| 3 - Remover       |\n");
        printf("_____________________\n");
        printf("| 9 - Sair           |\n");
        printf("_____________________\n|--->");
        scanf("%d", &opc);
        printf("_____________________\n");
        
        switch (opc) {
            case 1:
                printf("Insira o valor do nó da pilha: ");
                int val;
                scanf("%d", &val);
                insere(ini, val);
                break;
            case 2:
                imprime(ini);
                break;
            case 3:
                remove(ini);
                break;
            case 9:
                break;
            default:
                printf("Opção inválida.\n");
                break;
        }
    }
}

gistfile5.txt

Pilha com vetor

#include <stdio.h>
#include <stdlib.h>
#define MAX 5

typedef struct {
    int item[MAX];
    int topo;
} Pilha;
Pilha* criaPilha()
{
    Pilha *p;
    p = (Pilha *)malloc(sizeof(Pilha));
    p->topo=0;
    return p;
}
void Imprime( Pilha *p)
{
    int i;
    if(p->topo > 0)
    {
        for(i=p->topo-1; i>=0; i--)
        {
            printf(" %d ",p->item[i]);
        }
    }
    else
    {
        printf(" Lista vazia!\n");
    }
}
void Inserir( int x, Pilha *p)
{
    if(p->topo < MAX)
    {
        p->item[p->topo] = x;
        p->topo++;
    }
    else
    {
        printf("Pilha cheia!!!!Nao foi possivel a insercao");
    }
}
int Remover(Pilha *p)
{
    int x;
    if(p->topo>0)
    {
        x = p->item[p->topo-1];
        p->topo--;
        return x;
    }
    else
    {
        printf("Pilha vazia!!!!Nao foi possivel a remocao\n");
        return 0;
    }
}
int main(){
    Pilha *stack1;
    int opcao, item;
    stack1 = criaPilha();
    printf("PILHA COM VETOR\n");
    do
    {
        printf("\nDigite 1 para adicionar item, 2 para tirar item, 3 para mostrar pilha, 0 para sair: ");
        scanf("%d",&opcao);
        printf("\n");
        switch(opcao)
        {
            case 1:
                printf(" Digite o numero item: ");
                scanf("%d",&item);
                Inserir(item, stack1);
                break;
            case 2:
                item = Remover(stack1);
                printf(" Item %d deletado com sucesso!\n",item);
                break;
            case 3:
                Imprime(stack1);
                printf("\n");
                break;
        }
    }
    while(opcao != 0);
}

gistfile6.txt

Insertion sort

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define MAX 100
struct lista {
    int vetor[MAX];
    int tamanho;
};
typedef struct lista Lista;
void inserir(Lista *lista){
    int v;
    char op;
    do{
        system("cls");
        printf("Informe o valor: ");
        scanf("%d",&v);
        lista->vetor[lista->tamanho] = v;
        lista->tamanho++;
        printf("Desejar inserir outro valor (s/n)?: ");
        scanf("%s",&op);
    }while(op!='n');
    
}
void remover(Lista *lista){
    int i, j, v;
    system("cls");
    
    printf("Qual Valor deseja remover?: ");
    scanf("%d",&v);
    
    for(i=0; i<MAX; i++){
        if(lista->vetor[i]==v){
            for(j=i; j<MAX; j++){
                lista->vetor[j] = lista->vetor[j+1];
            }
            i=MAX;
        }
    }
    lista->tamanho--;
    
}
void insertionSort(Lista *lista)
{
    int aux;
    int temp;
    int troca;
    for (aux=1; aux < lista->tamanho; aux++) // aux começa na posição 1 do vetor e vai até a ultima posição;
    {
        temp = aux; // temp recebe a posição que está passando no "for";
        while (lista->vetor[temp] < lista->vetor[temp-1]) // Enquanto o valor que está passando na posição "temp" for menor que a posição "temp" menos 1, ocorre a troca;
        { // Ocorre a troca;
            troca = lista->vetor[temp];
            lista->vetor[temp] = lista->vetor[temp-1];
            lista->vetor[temp-1] = troca;
            temp--; // temp decrementa 1;
            if (temp == 0) // Quando "temp" chegar na posição 0, primeira posição do vetor, o laço while para;
                break;
        }
    }
}
void imprimir(Lista *lista){
    int t, i;
    t = lista->tamanho;
    for(i=0; i<t; i++){
        printf("\n%d", lista->vetor[i]);
    }
    printf("\n");
    system("pause");
}
int main(){
    Lista *lista;
    lista = (Lista*)malloc(sizeof(Lista));
    lista->tamanho=0;
    int op;
    
    do{
        system("cls");
        printf("\tESCOLHA A OPÇAO\n");
        printf("0 - Sair\n");
        printf("1 - Inserir\n");
        printf("2 - Remover\n");
        printf("3 - Imprimir\n");
        printf("4 - Ordenar\n");
        scanf("%d", &op);
        
        switch(op){
            case 0:
                printf("\tSAINDO");
                break;
                
            case 1:
                inserir(lista);
                break;
                
            case 2:
                remover(lista);
                break;
                
            case 3:
                imprimir(lista);
                break;
                
            case 4:
                insertionSort(lista);
                imprimir(lista);
                break;
            default:
                printf("\tOpção invalida!!\n");
                system("pause");
        }
    }while(op!=0);
}