1. Exemplos
1.1. Lista encadeada : struct elemento { int info; struct elemento* prox; }; typedef struct elemento Elemento; int main (void) { Elemento* lst; /* declara uma lista não inicializada */ lst = lst_cria(); /* cria e inicializa lista como vazia */ lst = lst_insere(lst, 23); /* insere na lista o elemento 23 */ lst = lst_insere(lst, 45); /* insere na lista o elemento 45 */ ... return 0; }
1.2. Pilha com Vetores : #include <stdio.h> #include <stdlib.h> #include "Pilha.h" #define MaxTam 1000 struct tipoitem { int valor; /* outros componentes */ }; struct tipopilha { TipoItem Item[MaxTam]; int Topo; }; TipoPilha* InicializaPilha(){ TipoPilha* pilha =(TipoPilha*)malloc(sizeof(TipoPilha)); return pilha; } void FPVazia(TipoPilha* Pilha){ Pilha->Topo = 0; } int Vazia (TipoPilha* Pilha) { return (Pilha->Topo == 0); } void Empilha (TipoItem* x, TipoPilha* Pilha) { if (Pilha->Topo == MaxTam) printf ("Erro: pilha esta cheia\n"); else { Pilha->Item[Pilha->Topo] = *x; Pilha->Topo++; } } void Desempilha (TipoPilha* Pilha, TipoItem* Item) { if (Vazia (Pilha)) printf ("Erro: pilha esta vazia\n"); else { *Item = Pilha *Item = Pilha ->Item[Pilha >Item[Pilha ->Topo -1]; Pilha->Topo--; } } int Tamanho (TipoPilha* Pilha) { return (Pilha->Topo); }
1.3. Fila : struct Fila { int capacidade; float *dados; int primeiro; int ultimo; int nItens; }; void criarFila( struct Fila *f, int c ) { f->capacidade = c; f->dados = (float*) malloc (f->capacidade * sizeof(float)); f->primeiro = 0; f->ultimo = -1; f->nItens = 0; } void inserir(struct Fila *f, int v) { if(f->ultimo == f->capacidade-1) f->ultimo = -1; f->ultimo++; f->dados[f->ultimo] = v; // incrementa ultimo e insere f->nItens++; // mais um item inserido } int remover( struct Fila *f ) { // pega o item do começo da fila int temp = f->dados[f->primeiro++]; // pega o valor e incrementa o primeiro if(f->primeiro == f->capacidade) f->primeiro = 0; f->nItens--; // um item retirado return temp; }
1.4. Array - Matriz: #include <stdio.h> void main(void) { int i, j, tabela[4][5]; for (i = 0; i < 4; i++) for (j = 0; j < 5; j++) tabela[i][j] = 2*i + 2*j + 1; for (i = 0; i < 4; i++) { for (j = 0; j < 5; j++) printf(“%d ”, tabela[i][j]); printf(“'\'”); } }
2. Tipos de Estruturas
2.1. HOMOGÊNEA - que agrupa valores de um mesmo tipo
2.1.1. Array (Arranjo)
2.1.1.1. Vetor
2.1.1.1.1. O que é? É um conjunto de informações de um mesmo tipo armazenadas em uma posição contígua de memória, com uma ordem indexada.
2.1.1.1.2. Quando se usa? É usado quando um conjunto de dados de mesmo tipo precisa ser armazenado em uma mesma estrutura
2.1.1.2. Matriz
2.1.1.2.1. O que é? É uma coleção de variáveis de um mesmo tipo, que pode ser unidimensional(Vetor) ou bidimensional.
2.1.1.2.2. Quando se usa? É usada quando é preciso armazenar um ou mais valores ou dados de um mesmo tipo.
2.2. HETEROGÊNEAS - que agrupa valores ou de dados de diferentes tipos.
2.2.1. Queue(Fila)
2.2.1.1. O que é? É uma estrutura do tipo FIFO(first in, first out), em que só pode haver adição(enqueue) de um elemento no final da fila só se remove(dequeue) no início da mesma.
2.2.2. Stack(Pilha)
2.2.2.1. O que é? É uma estrutura do tipo LIFO(last in, first out), em que só pode haver adição(push) ou remoção(pop) de um elemento no topo da pilha.
2.2.3. List (Lista)
2.2.3.1. O que é? É uma estrutura formada por um conjunto de dados mantendo a relação de ordem linear entre os mesmos. É composta de nós( conjunto de dados) que podem conter dados de tipos primitivos( int, char...) ou compostos( struct).
2.2.3.2. Estática
2.2.3.2.1. Sequêncial
2.2.3.2.2. não Sequêncial
2.2.3.3. Dinâmica
2.2.3.3.1. Encadeada
2.2.3.3.2. Duplamente Encadeada