Criando um banco de dados no MySQL

O MySQL é um SGBD com licença GPL. O que quer dizer que ele é totalmente gratuito.
Por esse e outros motivos ele é um dos banco de dados mais utilizados.
Apesar disso veremos aqui a linguagem SQL que é também utilizada nos outros bancos de dados. Sendo assim esses comandos também serão válidos para outros bancos de dados.
Download MySQL para Windows.
Depois de instalar o MySQL você deve criar seu banco de dados através do Command Line Cliente.
Existem vários programa do tipo Front-end para manipular os seus banco de dados. Mais antes de conhece-los é interessante você usar as linhas de comandos para atividades mais simples. Isso fará com que você entenda melhor qualquer SGBD que você vá utilizar.
Com SQL utilizamos o comando create database bd01; para criar um banco de dados.
Sendo bd01 o nome que dei ao meu banco de dados.
Para ver seus databases use o comando show databases;

Observe na imagem que nosso banco de dados bd01 já foi criado. Vamos então acessa-lo com o comando use bd01;
Ainda não há nada dentro de nosso banco de dados. Se utilizarmos o comando show tables; recebemos a mensagem Empty set.
Para criar tabelas dentro do nosso banco de dados usamos o comando:

CREATE TABLE NOME
(
campo1 tipo,
campo2 tipo
...
);

Exemplo:

CREATE TABLE FUNCIONARIOS
(
fun_codigo integer,
fun_nome varchar(40),
fun_endereco varchar(40),
fun_cargo varchar(15),
fun_salario numeric(5,2),
fun_sexo char(1)
);

Neste comando criamos uma tabela com o nome FUNCIONARIOS e definimos 6 campos para ela:
fun_codigo: campo do código do funcionário do tipo inteiro (integer).
fun_nome: campo para armazenar o nome do funcionário. Seu tipo é de texto com até 40 caracteres.
fun_endereco: campo para armazenar o endereço do funcionário. Seu tipo é de texto com até 40 caracteres.
fun_cargo: campo para armazenar o cargo do funcionário. Seu tipo é de texto com até 15 caracteres.
fun_salario: campo para armazenar o salário do funcionário. Seu tipo é numérico com 5 casas a esquerda (antes de vírgula) e 2 a direita (depois da vírgula).
fun_sexo: campo para armazenar o sexo do funcionário. Seu tipo é de caractere. Podemos armazenar F (feminino) e M (masculino).
Existem diversas outras regras que podemos adicionar a estes campos. Nesse caso criamos uma tabela simples apenas para exemplificar melhor a criação de uma novo banco de dados.
Antes de criar seu banco de dados analise oque você realmente deve armazenar para não criar campos ou tabelas que não tenham real utilidade.

Insertion Sort - Linguagem C

O método Insertion Sort é simples e bem mais eficiente que os outros métodos vistos: Bubble Sort e Selection Sort.

Um exemplo clássico ao explicar este método é o de ordenar um baralho passando as cartas da mão direita para a mão esquerda passando carta por carta.

#define TAM 10
void insertion_sort(int v[])
{
    int i, j, aux;
    for(i = 1; i < TAM; i++)
    {
        aux = v[i];
        j = i - 1;
        while((j >= 0) && (aux < v[j]))
        {
            v[j+1] = v[j];
            j--;
        }
        v[j+1] = aux;
    }
}

main()
{
    int i, vet[TAM] = {10,9,3,6,7,5,1,8,4,2};
    printf("Vetor atual: ");
    for(i = 0; i < TAM; i++)
        printf("%d ", vet[i]);
    printf("\n");
    system("pause");
    insertion_sort(vet);
    printf("\n\nVetor ordenado: ");
    for(i = 0; i < TAM; i++)
        printf("%d ", vet[i]);
    printf("\n");
    system("pause");
    return 0;
}

Neste método a quantidade de iterações dependerá de quão desordenado está o vetor.
Para verificar a quantidade de iterações podemos criar uma variável global e mandar incrementa-la a cada vez que entrar no laço for e no laço while e mandar imprimi-la no final para ver o resultado.
Dessa forma:

#define TAM 10
int k = 0;
void insertion_sort(int v[])
{
    int i, j, aux;
    for(i = 1; i < TAM; i++)
    {
        aux = v[i];
        j = i - 1;
        while((j >= 0) && (aux < v[j]))
        {
            v[j+1] = v[j];
            j--;
            k++;
        }
        v[j+1] = aux;
        k++;
    }
}

main()
{
    int i, vet[TAM] = {10,9,3,6,7,5,1,8,4,2};
    printf("Vetor atual: ");
    for(i = 0; i < TAM; i++)
        printf("%d ", vet[i]);
    printf("\n");
    system("pause");
    insertion_sort(vet);
    printf("\n\nVetor ordenado: ");
    for(i = 0; i < TAM; i++)
        printf("%d ", vet[i]);
    printf("\nk = %d",k);
    system("pause");
    return 0;
}

O resultado neste caso é 42 iterações. Pode parecer pouco, mais quando aumentamos a quantidade de posições do vetor a diferença aumenta.

Selection Sort - Linguagem C

O método de ordenação Selection Sort é pouca coisa mais eficiente que o método Bubble Sort.
Com o Selection Sort percorremos o vetor e guardamos sempre o menor valor. Chegando ao fim do vetor teremos então a primeira posição. A partir da próxima iteração o primeiro vetor já não precisa mais ser verificado pois ele já está ordenado.
Observaremos que o método Selection Sort terá a mesma quantidade de iterações que o método Bubble Sort. Para descobrir nesse caso a quantidade de iterações podemos fazer a seguinte fórmula para um vetor de 10 posições:
(n-1)+(n-2)+(n-3)+(n-4)+(n-5)+(n-6)+(n-8)+(n-8)
Sendo n o tamanho do vetor, temos o resultado: (9)+(8)+(7)+(6)+(5)+(4)+(3)+(2) = 44 iterações.

Apesar de os 2 terem a mesma quantidade de iterações, no método Selection Sort temos uma leve vantagem quando comparamos a quantidade de trocas. No método Selection Sort armazenamos o menor valor e somente ao final da primeira passada completa pelo vetor que fazemos a troca.

#define TAM 10
void selection_sort(int v[])
{
    int i, j, aux, menor;
    for(i = 0; i < TAM; i++)
    {
        menor = i;
        for(j = i+1; j < TAM; j++)
        {
            if(v[j] < v[menor])
                menor = j;
        }
        if(i != menor)
        {
            aux = v[i];
            v[i] = v[menor];
            v[menor] = aux;
        }
    }
}

main()
{
    int i, vet[TAM] = {10,9,3,6,7,5,1,8,4,2};
    printf("Vetor atual: ");
    for(i = 0; i < TAM; i++)
        printf("%d ", vet[i]);
    printf("\n");
    system("pause");
    selection_sort(vet);
    printf("\n\nVetor ordenado: ");
    for(i = 0; i < TAM; i++)
        printf("%d ", vet[i]);
    printf("\n");
    system("pause");
    return 0;
}

Nesse código criei a função que ordena com o método Selection Sort. Podemos assim mandar o vetor como argumento para ser ordenado por nossa função. Para facilitar a visualização do que ocorreu na função eu criei um vetor com valores de 1 a 10 embaralhados e mandei imprimir esses números antes de serem ordenados e depois de serem ordenados.
O algoritmo do selection sort pode ser desenvolvido usando outras lógicas que no final terão o mesmo resultado.
Tanto o método Selection Sort quanto o método Bubble Sort não apresentam boa eficiência para ordenação de grandes vetores. Porém, é importante estuda-los para melhor entender os outros métodos de ordenação que foram basicamente melhoras desses métodos com menor eficiência.

Métodos de ordenação de vetores

• Bubble Sort - Linguagem C
• Selection Sort - Linguagem C
• Insertion Sort - Linguagem C
• Merge Sort - Linguagem C
• Bucket Sort - Linguagem C
• Quick Sort - Linguagem C

Bubble Sort - Linguagem C

O método de ordenação bubble sort é um método muito simples de ordenação. Porém, seu desempenho é muito ruim. Quanto maior o vetor a ser ordenado por ele, pior será seu desempenho.

Fiz um trabalho em MATLAB recentemente na faculdade onde eu apresentava essa diferença gritante entre o método bubble sort e o método shell sort.
Vou publicar hoje o método bubble sort em C e em breve darei sequencia com outros métodos de ordenação.
O método bubble sort (Ordenação bolha) recebeu esse nome por que durante sua ordenação os maiores números são ordenados primeiro, como as bolhas de um recipiente onde as maiores chegam primeiro a superfície. Ou seja, ele compara todos os números do início ao fim do vetor e sempre que o primeiro for maior ele inverte as posições. Terminando de verificar o vetor a primeira vez ele terá encontrado o maior número e na próxima passada ele não verificará o ultimo número ordenado.

void bubbleSort(int v[], int tam)
{
    int i, j, aux, troca;
    for(i = 0; i < tam; i++)
    {
        troca = 0;
        for(j = 0; j < (tam-1)-i; j++)
        {
            if(v[j] > v[j+1])
            {//realiza troca dos elementos
                aux = v[j];
                v[j] = v[j+1];
                v[j+1] = aux;
                troca = 1;
            }
        }
        //se não foram realizadas trocas, vetor já está ordenado
        if(troca == 0) 
            break; //sai do laço
    }
}

int main(int argc, char *argv[])
{
    int i, vet[10] = {10,9,3,6,7,5,1,8,4,2};
    printf("Vetor atual: ");
    for(i = 0; i < 10; i++) //mostrar vetor desordenado
        printf("%d ", vet[i]);
    printf("\n");
    system("pause"); //pausar
    bubbleSort(vet, 10); //chamada a função bubble enviando vetor e tamanho dele
    printf("\n\nVetor ordenado: ");
    for(i = 0; i < 10; i++) //mostrar vetor ordenado
        printf("%d ", vet[i]);
    printf("\n");
    system("pause"); //pausar
    return 0;
}

Nesse código criei a função que ordena com o método Bubble Sort. Podemos assim mandar o vetor como argumento para ser ordenado por nossa função. Para facilitar a visualização do que ocorreu na função eu criei um vetor com valores de 1 a 10 embaralhados e mandei imprimir esses números antes de serem ordenados e depois de serem ordenados.
O algoritmo do bubble sort pode ser desenvolvido usando outras lógicas que no final terão o mesmo resultado. Porém, além deste método existem outros mais eficientes.

Função em Linguagem C - Gerador de CPF

Em outro post expliquei sobre a fórmula do CPF e também publiquei o código fonte de um validador de CPF.
Se você quer saber como funciona a fórmula do CPF acesse: Validador de CPF
Agora estou publicando um gerador de CPF em linguagem C.
Para fazer esta função utilizei também duas funções da biblioteca da linguagem C para gerar números aleatórios: rand e srand. Caso não às conheça acesse o post onde expliquei sobre elas.

#include <stdlib.h>
char cpf[11];

void cpf_generator()
{
    int i, j, dig = 0;
    srand(time(NULL));
    for(i = 0; i <= 9; i++)
        cpf[i] = (rand() % 10) + 48;
    for(i = 0, j = 10; i <= strlen(cpf)-2; i++, j--)
        dig += (cpf[i]-48) * j;
    dig %= 11;
    if(dig < 2)
        cpf[9] = 48;
    else
        cpf[9] = (11-dig)+48;
    dig = 0;
    for(i = 0, j = 11; i <= strlen(cpf)-1; i++, j--)
    {
        dig += (cpf[i]-48) * j;
    }
    dig %= 11;
    if(dig < 2)
        cpf[10] = 48;
    else
        cpf[10] = (11-dig)+48;
}

main()
{
    int i;
    cpf_generator();
    printf("\n");
    for(i = 0; i < 11; i++)
        printf("%c", cpf[i]);
    printf("\n");
    system("pause");
    return 0;
}

Função em linguagem C - Validador de CPF

Fórmula CPF:
Vamos usar como exemplo o CPF 232.315.171-17.
Os 2 últimos dígitos, nesse caso 17, são os "validadores" do CPF. Mas como fazemos para valida-los? Como chegar a esses dígitos?

Primeiro dígito:

Para o primeiro dígito (1) devemos usar os 9 primeiros números do CPF, multiplicando de 10 à 2, como ilustrado na tabela abaixo:

CPF	2	3	2	3	1	5	1	7	1
Multiplicadores	10	9	8	7	6	5	4	3	2
Resultado	20	27	16	21	6	25	4	21	2	Total: 142

O total deve ser dividido por 11 (142/11) e posteriormente 11 deve ser subtraído pelo resto da divisão.
142 / 11 = 12 e resto = 10
Regra: se o resto da divisão for menor que 2 o primeiro dígito será 0.
Como nosso resto não é menor que 2 subtraímos a quantidade de dígitos pelo resto: 11-10 = 1
E assim achamos o nosso primeiro dígito: 1

Segundo dígito:

Para o segundo dígito devemos usar os 10 primeiros dígitos, incluindo o que achamos fazendo a primeira fórmula, multiplicando de 11 à 2, como ilustra a tabela abaixo:

CPF	2	3	2	3	1	5	1	7	1	1
Multiplicadores	11	10	9	8	7	6	5	4	3	2
Resultado	22	30	18	24	7	30	5	28	3	2	Total: 169

O total deve ser dividido por 11 (169/11) e posteriormente 11 deve ser subtraído pelo resto da divisão.
169 / 11 = 15 e resto = 4
Regra: se o resto da divisão for menor que 2 o segundo dígito será 0.
Como nosso resto não é menor que 2 subtraímos a quantidade de dígitos pelo resto: 11-4 = 7
E assim achamos o nosso segundo dígito: 7
Validamos então nosso CPF, pois os dois dígitos que achamos são iguais aos do CPF: 232.315.171-17.
Regra: Além das regras citadas acima o CPF não pode também ter todos os números iguais como, por exemplo: 111.111.111-11.

Função em C para validar o CPF:

int validarCPF(char cpf[])
{
    int i, j, digito1 = 0, digito2 = 0;
    if(strlen(cpf) != 11)
        return 0;
    else if((strcmp(cpf,"00000000000") == 0) || (strcmp(cpf,"11111111111") == 0) || (strcmp(cpf,"22222222222") == 0) ||
            (strcmp(cpf,"33333333333") == 0) || (strcmp(cpf,"44444444444") == 0) || (strcmp(cpf,"55555555555") == 0) ||
            (strcmp(cpf,"66666666666") == 0) || (strcmp(cpf,"77777777777") == 0) || (strcmp(cpf,"88888888888") == 0) ||
            (strcmp(cpf,"99999999999") == 0))
        return 0; ///se o CPF tiver todos os números iguais ele é inválido.
    else
    {
        ///digito 1---------------------------------------------------
        for(i = 0, j = 10; i < strlen(cpf)-2; i++, j--) ///multiplica os números de 10 a 2 e soma os resultados dentro de digito1
            digito1 += (cpf[i]-48) * j;
        digito1 %= 11;
        if(digito1 < 2)
            digito1 = 0;
        else
            digito1 = 11 - digito1;
        if((cpf[9]-48) != digito1)
            return 0; ///se o digito 1 não for o mesmo que o da validação CPF é inválido
        else
        ///digito 2--------------------------------------------------
        {
            for(i = 0, j = 11; i < strlen(cpf)-1; i++, j--) ///multiplica os números de 11 a 2 e soma os resultados dentro de digito2
                    digito2 += (cpf[i]-48) * j;
        digito2 %= 11;
        if(digito2 < 2)
            digito2 = 0;
        else
            digito2 = 11 - digito2;
        if((cpf[10]-48) != digito2)
            return 0; ///se o digito 2 não for o mesmo que o da validação CPF é inválido
        }
    }
    return 1;
}

Há um loop para cada dígito para ser calculado seu valor.
Se um dos dígitos não conferir com o do CPF o programa já retorna 0, informando assim que o CPF é inválido. Caso contrário a função continua para o próximo loop que faz o calculo do segundo dígito. Se este não conferir com o ultimo dígito do CPF o programa retorna 0, senão é retornado o valor 1 indicando que o CPF é válido.
Veja também: Gerador de CPF.

MATLAB - Comparação entre Bubble Sort e Shell Sort

Estou compartilhando hoje um trabalho interessante que eu e mais alguns amigos da faculdade desenvolvemos em MATLAB. Não temos aulas dessa linguagem na faculdade, mas nosso professor de programação estruturada sorteou algumas linguagens e pediu que o grupo desenvolvesse um programa de 30 a 50 linhas nessa linguagem.
Ninguém do nosso grupo tinha conhecimentos sobre MATLAB. Tivemos pouco menos de 2 meses para aprender pelo menos um pouco sobre a linguagem por conta própria. Isso tudo com o intuito de nos incentivar a auto aprendizagem.
Inicialmente não sabia oque fazer...
Nesse semestre fizemos alguns estudos simples sobre métodos de ordenação de vetores. Eu gostei do assunto, pesquisei outros métodos e programei alguns deles em C. Isso me incentivou a fazer esse script e ver o tempo que leva para um script em Bubble Sort ser ordenado e essa mesma ordenação em um método mais eficiente, neste caso o Shell sort.
Tanto o Shell Sort quanto o Bubble Sort são algoritmos curtos, por isso estes foram os escolhidos. Ainda assim nosso programa ficou com 52 linhas (não contamos as linhas de comentários).

Créditos a todos os membros do grupo:
Alessandro Araujo Rodrigues;
Erick Rondinone Chalegre;
Gean Miguel Falcão Dos Anjos;
George Henrique Wurthmann;
Leandro Carvalho Nogueira;

DESCRIÇÃO DO PROGRAMA
Programa desenvolvido com MATLAB para analisar o desempenho do método de organização de dados Bubble sort e também do método Shell sort, os dados do vetor foram lidos a partir de arquivo (planilha do excel). Ao fim da organização é apresentado um gráfico comparativo entre os dois métodos. Em um deles é apresentado a quantidade de iterações realizadas para se fazer a ordenação e no outro é apresentado o tempo em milissegundos utilizado para se fazer toda a ordenação.
Para a realização desses testes foram utilizados 2000 (dois mil) números aleatórios que estão armazenados em um arquivo do Excel (ordenar.xlsx). Esses números foram gerados aleatoriamente através do Excel com auxilio das funções rand e int. Para comprovar a funcionalidade do programa, esse script ainda escreve nesse mesmo arquivo do Excel (ordenar.xlsx) os números ordenados, tanto do bubble sort quanto do shell sort.

PROGRAMA

%%%%% %%%%% %%%%%BUBBLE SORT %%%%% %%%%% %%%%%
        importdata('ordenar.xlsx');
        input('Números a serem ordenados: ');
        disp(xlsread('ordenar.xlsx','B1:B2000'))
        x = [xlsread('ordenar.xlsx','B1:B2000')]; n = length(x); iterations_bs = 0;
        time_aux1 = float('single'); time_aux1 = clock;
        for(i2 = 1:n-1)
            troca = 0;
            for(j2 = 1:n-i2)
             if(x(j2) > x(j2+1))
                 aux = x(j2);
                 x(j2) = x(j2 + 1);
                 x(j2 + 1) = aux;
                 troca = 1;
             end
             iterations_bs = iterations_bs + 1;
         end
         if(troca == 0)
             break;
         end
     end
     time_aux2 = float('single');time_aux2 = clock;
     time_bs = float('single'); time_bs = ((time_aux2(5)- time_aux1(5))*60)+(time_aux2(6)- time_aux1(6));
     input('Ordenação Bubble sort:');
     disp(x)
     xlswrite('ordenar.xlsx',x,'E1:E2000');
     %%%%% %%%%% %%%%%SHELL SORT %%%%% %%%%% %%%%%
     input('Ordenação Shell sort:');
     x = [xlsread('ordenar.xlsx','B1:B2000')]; iterations_ss = 0; time_aux1 = clock;
     inc = cast(n/2,'int16');
     while(inc>0)
       for(i2=inc+1:n)
         aux = x(i2);
         j2 = i2;
         while(j2>inc && x(j2-inc)>aux)
     x(j2) = x(j2-inc);
           j2 = j2-inc;
           iterations_ss = iterations_ss + 1;
         end
         x(j2) = aux;
         iterations_ss = iterations_ss + 1;
       end
       inc = cast(floor(double(inc) /2),'int16');
     end
     time_aux2 = clock;
     time_ss = float('single'); time_ss = ((time_aux2(5)- time_aux1(5))*60)+(time_aux2(6)- time_aux1(6));
     disp(x)
     xlswrite('ordenar.xlsx',x,'H1:H2000');
     %%%%%%%Comparação entre os modos de ordenação%%%%%%%
     graph = [iterations_bs iterations_ss];
     graphtime = float('single'); graphtime = [time_bs time_ss];
     input('Bubble sort: Quantidade de iterações: '); disp(iterations_bs);
     input('Bubble sort: Tempo em segundos: '); disp(time_bs);
     input('Shell sort: Quantidade de iterações: '); disp(iterations_ss);
     input('Shell sort: Tempo em milisegundos: '); disp(time_ss);

EXPLICAÇÃO DO CÓDIGO 
Linha 1: Comentário para separação do método Bubble_Sort.
Linha 2: Importa os dados do arquivo “ordenar.xlsx”.
Linha 3: Informa a seguinte mensagem na tela: “Números a serem ordenados”.
Linha 4: Mostra o que o sistema leu entre as células B1 à B2000.
Linha 5: Atribui ao vetor “x” os dados de B1 à B2000, e em “n”atribuímos o tamanho do vetor “x” (2000 posições) e iniciamos a variável “iterations_bs” com valor zero.
Linha 6: Iniciamos o vetor “time_aux1” como “float” (Real), e atribuímos a mesma os valores relacionados ao relógio do computador local (Função Clock), sendo este o momento em que a ordenação se iniciou. Obs.: A função clock armazena em um vetor de 6 posições, sendo elas para: ano, mês, dia, horas, minutos, segundos.
Linha 7: Iniciamos uma repetição que ira de 1 (i2) até 1999 (n-1). Essa repetição percorrerá o vetor “x”.
Linha 8: Iniciamos a variável troca com o valor zero.
Linha 9: Repetição que irá de 1 até n-i2. Como “n” decrementa o valor de “i2” a cada repetição a posição até qual se percorrerá será diminuída em um.
Linha 10: Condição para trocar/Não Trocar.
Linha 11 à 13: É utilizada a variável “aux”, para inverter os valores de posição caso a condição seja verdadeira (Linha 10).
Linha 14: Atribui a variável “troca” o valor 1 (um). Obs.: Essa variável é utilizada para verificar se houve alguma troca durante o laço.
Linha 15: Fechamento do bloco “if”.
Linha 16: Incrementa a variável “iterations_bs” em 1 (um).
Linha 17: Fechamento do bloco “for”.
Linha 18 à 20: Se não houver troca, interrompe o laço.
Linha 21:Fechamento do bloco “for”.
Linha 22:Iniciamos o vetor “time_aux2” como float (Real), e atribuímos a mesma os valores relacionados ao relógio do computador local (Função Clock), sendo este o momento em que a ordenação se finalizou. Obs.: A função clock armazena em um vetor de 6 posições, sendo elas para: ano, mês, dia, horas, minutos, segundos.
Linha 23:Atribui a variável “time_bs” o calculo do tempo de execução. (time_aux2 - time_aux1). No calculo usamos apenas as posições 5 e 6, que são, respectivamente, referentes a minutos e segundos. Linha 24:Informa a seguinte mensagem na tela: “Ordenação Bubble sort”.
Linha 25: Mostra o vetor “x” já ordenado.
Linha 26: Escreve no arquivo “ordenar.xlsx” o vetor “x” de E1 à E2000.
Linha 27: Comentário para separação do método Shell Sort.
Linha 28: Informa a seguinte mensagem na tela “Ordenação Shell sort”.
Linha 29: Atribui ao vetor “x” novamente os valores desordenados (B1 à B2000),iniciamos a variável “iterations_ss” com valor 0 (zero) e atribuímos a “time_aux1” os valores relacionados ao relógio do computador local (Função Clock),sendo este o momento em que a ordenação se iniciou.
Linha 30: Atribuímos a variável “inc” o valor de (n/2) e com a função cast convertemos o numero para inteiro.
Linha 31: Repetir enquanto “inc” for maior que 0 (zero).
Linha 32:Repetir de “inc+1” até “n”.
Linha 33: A variável “aux” recebe o valor do vetor x(i2) para caso seja realizada a troca posteriormente.
Linha 34: Atribui a variável “j2” o valor de “i2” (como não podemos mudar o valor de “i2”, pois é um contador, passamos o valor para “j2” para podermos manipula-lo).
Linha 35 à 37: Enquanto as condições forem verdadeiras, sãoinvertidas as posições dos valores do vetor (Iniciado a troca).
Linha 38: Incrementa a variável “iterations_ss” em 1 (um).
Linha 39: Fechamento do bloco “while”.
Linha 40: Finalizando a troca das posições do vetor.
Linha 41: Incrementa a variável “iterations_ss” em 1 (um).
Linha 42: Fechamento do bloco “for”.
Linha 43: Atribuímos a variável “inc” o valor de (n/2) e com a função cast convertemos o numero para inteiro. A função “floor” arredonda para menos e a função “double” aumenta a precisão para evitar arredondamentos errôneos.
Linha 44: Fechamento do bloco “while”.
Linha 45: Atribuímos ao “time_aux2” os valores relacionados ao relógio do computador local (Função Clock), sendo este o momento em que a ordenação se finalizou.
Linha 46: Inicia-se a variável time_ss como “float” (Real) e atribui a estao valordo calculo do tempo de execução. (time_aux2 - time_aux1).
Linha 47: Mostra os valores do vetor “x” (Números ordenados).
Linha 48: Escreve no arquivo “ordenar.xlsx” o vetor “x” ordenado, de H1 à H2000.
Linha 49: Comentário para separação da parte onde fazemos as comparações.
Linha 50: Armazena no vetor “graph” o valor “iterations_bs” e “iterations_ss”. Vetor de 2 (duas) posições.
Linha 51: O vetor “graphtime” é iniciado como “float” (Real). Atribuindo a esta o valor de “time_bs” e “time_ss”. Vetor de 2 (duas) posições.
Linha 52 à 55: Mostra ao usuário os resultados da comparação (Quantidade de iterações e Tempo de execução de cada um).

IMAGENS DO PROGRAMA

Figura 1.0 A imagem acima representa a tela inicial do programa, onde é apresentado para o usuário os números na ordem atual (os números a serem ordenados).

Figura 1.1A imagem acima representa a ordenação feita pelo método Bubble sort.

Figura 1.2A imagem acima representa a ordenação feita pelo método Shell sort.

Figura 1.3A imagem acima apresenta a tela do programa que mostra ao usuário a quantidade de iterações e o tempo em milissegundo de cada um dos métodos utilizados em nosso programa (Bubble sort e Shell sort).

Figura 1.4 Ao lado podemos observar a “Workspace” do MATLAB, onde são mostradas as variáveis utilizadas em nosso programa.

Quatro dessas variáveis foram utilizadas para gerar um gráfico de comparação entre os 2 métodos que utilizamos em nosso programa. São elas:  iterations_bs, iterations_ss, time_bs e time_ss.

Os gráficos devem ser gerados a partir de vetores ou matrizes, então armazenamos no vetor graph as variáveis iterations_bs e iterations_ss e no vetor graphtime as variáveis time_bs e time_ss.

Através desses vetores geramos os dois gráficos de comparação através do botão contornado de vermelho (Select data to plot).

Figura 1.5 A imagem acima mostra o gráfico que compara a quantidade de iterações realizadas pelo Bubble sort (coluna esquerda) e a quantidade de iterações realizadas pelo Shell sort (coluna direita).

Figura 1.6 A imagem acima mostra o gráfico que compara o tempo em que foi feita a ordenação pelo Bubble sort (coluna esquerda) e o tempo em que foi feita a ordenação pelo Shell sort (coluna direita).

Figura 1.7 A imagem acima mostra o arquivo do Excel (ordenar.xlsx) onde geramos os números aleatórios utilizados em nosso programa. Tanto para o Bubble Sort quanto para o Shell Sort foram utilizados exatamente os mesmos números, que são os números que estão de B1 à B2000.

Figura 1.8:A imagem acima mostra o arquivo do Excel (ordenar.xlsx) com os números já ordenados, sendo a coluna E referente ao Bubble Sort e a coluna H referente ao Shell Sort. Podemos observar que o resultado é exatamente o mesmo, pois, como explicado anteriormente, as ordenações foram realizadas com os mesmos números para os dois métodos.

COMENTÁRIOS SOBRE A LINGUAGEM DE PROGRAMAÇÃO UTILIZADA

MATLAB é uma linguagem de programação muito poderosa. É claro que durante nossa pequena pesquisa não utilizamos todo seu poder, mas conseguimos observar bem isso através de sua biblioteca de funções. Existe uma quantidade enorme de comandos para os mais diversos usos.

Deparamo-nos com muito conteúdo para engenharia e matemática. Em nossas pesquisas observamos que engenheiros e matemáticos utilizam o MATLAB como ferramenta de pesquisa. Criam através dele modelos matemáticos ou simbólicos (gráficos) para auxiliar em seus projetos. E ainda é possível utiliza-lo para pesquisas cientificas, pois é de grande facilidade trabalhar com fórmulas no MATLAB e com grande velocidade. Além de tudo isso é possível utilizar os conceitos de orientação a objeto, criar funções, gráficos, trabalhar com som, etc.

Encontramos alguns vídeos bem explicados, entre eles, um dos que nos mais ajudou a entender a linguagem foram os próprios vídeos disponíveis no portal do MATLAB (http://www.mathworks.com/products/matlab/examples.html).

BIBLIOGRAFIA

CELES, Waldemar. CERQUEIRA, Renato. RANGEL, José Lucas. Introdução a Estruturas de Dados. 2004, Elsevier Editora.

http://das.ufsc.br/~nestor/cursos/matlab/matlab/matlab.html. Acesso em 19/10/2012 ás 15h22min.

http://www2.dcc.ufmg.br/disciplinas/aeds2_turmaA1/bubblesort.pdf. Acesso em 24/10/2012 ás 11h17min.

http://www.del.ufms.br/tutoriais/matlab/apresentacao.htm.Acesso em 24/10/2012 ás 11h40min.

http://www.ic.uff.br/~aconci/GuiaMatLab.pdf. Acesso em 24/10/2012 ás 09h32min.

http://www.mathworks.com/products/matlab/examples.html. Acesso em 25/10/2012 ás 12h09min.

http://www2.peq.coppe.ufrj.br/Pessoal/Professores/Arge/COQ897/Matlab/matlab.pdf. Acesso em 25/10/2012 ás 14h05min.

http://www.slideshare.net/ander-san/trabalho-shell-sort. Acesso em 19/10/2012 ás 11h16min.

http://www.youtube.com/playlist?list=PL4D57B6012FE85563. Acesso em 24/10/2012 ás 10h27min.

http://www.youtube.com/watch?v=CmPA7zE8mx0&feature=relmfu. Acesso em 19/10/2012 ás 10h03min.

http://www.youtube.com/watch?v=M3bS6w1R434. Acesso em 19/10/2012 ás 09h51min.

Criando Funções em C

Funções são instruções ou comandos que tem o objetivo de realizar uma tarefa específica.
Em C sempre criamos, pelo menos, a função principal do programa: main
A função main é obrigatória e será sempre a primeira a ser executada ao iniciar o seu programa. Outras funções podem receber qualquer nome, desde que não comecem como números e não contenham caracteres especias.
O uso de funções em seu programa traz muitos benefícios. Evitamos a repetição de um mesmo trecho várias vezes, podemos dividir partes do programa entre a equipe de desenvolvimento, onde cada membro ficará responsável por x função(ões).
Vamos criar uma função simples para imprimir uma linha:

void nl()
{
    printf("\n");
}

main()
{
    printf("Meu programa.");
    nl(); nl();
    printf("Uso de funcoes - linguagem C.");
    nl();
    system("pause");
}

Neste exemplo criei um função do tipo void bem simples que imprimi uma linha nova. O nome da função pode ser escolhida pelo programador, utilizei neste exemplo o nome nl referente a Nova Linha e fiz a chamada dessa função 3 vezes em meu programa.
Sempre que o programa é executado ele é iniciado pelo main, e todas as vezes em que fiz a chamada por nl(); ele vai até essa função e executa suas instruções.
Mais por que utilizar o tipo void?
As funções podem retornar valores depois de executar suas instruções, então, devemos informar o tipo do valor que ela retornará. Nesse caso a nossa função não retorna nenhum valor, por isso devemos inicia-la como void.
Exemplo de função que retorna um valor inteiro:

int soma()
{
    int num1 = 5, num2 = 10;
    return num1 + num2;
}

main()
{
    printf("%d\n",soma());
    system("pause");
}

No programa principal (main), pedimos para imprimir o valor da função soma, como o valor retornado por ela é do tipo inteiro, definimos seu espaço de impressão como "%d". Então a função é executada e ao fazer todas suas instruções nos devolve o valor 15.
É obvio que neste caso não era necessário o uso de uma função para fazer uma soma tão simples. Mais podemos ainda enviar parâmetros para as funções.
Vamos então melhorar as nossas funções nl e soma:

void nl(int n)
{
    int i;
    for(i = 0; i < n; i++)
        printf("\n");
}

main()
{
    printf("Meu programa.");
    nl(3);
    printf("Uso de funcoes - linguagem C.");
    nl(2);
    system("pause");
}

Implementamos na função nl a passagem de um parâmetro. Ao iniciar a função declaramos entre seus parenteses uma variável inteira. Ao chamar a função colocamos entre os parenteses o valor que desejamos passar para a função. Em nosso exemplo fizemos uma chamada enviando o valor 3 e outra enviando o valor 2, que define a quantidade de novas linhas que nossa função deve abrir.

int soma(int num1, int num2)
{
    return num1 + num2;
}

main()
{
    int n1, n2;
    printf("Digite os numeros a somar: \n");
    scanf("%d %d",&n1,&n2);
    printf("%d + %d = %d\n",n1,n2,soma(n1,n2));
    system("pause");
}

Implementamos na função soma a passagem de dois parâmetros. Ao iniciar a função declaramos entre seus parenteses duas variáveis do tipo inteiro. Ao chamar a função colocamos entre os parenteses o valor que desejamos passar para a função. Nesse caso passamos outras variáveis como valores para os parâmetros da função soma (n1 e n2), que receberam valores que foram digitados pelo usuário.

Matriz e Vetor - linguagem C

Vetores:
Vetor é uma variável que armazena vários valores de tipo homogêneo.
Por exemplo:
int var0[5]; é uma variável que armazena até 5 valores inteiros.
float var1[10]; é uma variável que armazena até 10 valores reais.
char var2[3]; é uma variável que armazena até 3 valores caracteres.

Para saber mais sobre tipos de dados acesse esse link.

Posições do vetor:

As posições do vetor em C iniciam-se sempre em 0. Ou seja, para um vetor de 5 posições percorremos as posições 0, 1, 2, 3 e 4. Para manipular o vetor int var0[5]; usamos as seguintes instruções: var[0], var[1], var[2], var[3] e var[4].

Atribuindo valor:
Atribuímos os valores de um vetor dentro de chaves. Exemplo: int var0[5] = {5,-8,3,0,-2};
Ou podemos atribuir valores de posições específicas: var0[2] = 10;


Podemos imaginar o vetor int var0[5]; da seguinte forma:

Posições	0	1	2	3	4
Valores	5	-8	3	0	-2

Exemplo:

main()
{
    int var0[5] = {5,-8,3,0,-2};
    printf("%d, %d, %d, %d , %d\n",var0[0], var0[1], var0[2], var0[3], var0[4]);
    system("pause");
    var0[2] = 10;
    printf("%d, %d, %d, %d , %d\n",var0[0], var0[1], var0[2], var0[3], var0[4]);
    system("pause");
}

Nesse programa primeiro aplicamos o valor de cada posição do vetor e posteriormente alteramos apenas a posição 2. Lembrando que a posição 2 de um vetor em C equivale ao terceiro valor do vetor, pois começamos a posição em 0 (zero).

Percorrendo um vetor:
Podemos percorrer um vetor usando um laço de repetição. Se você precisa, por exemplo, ler o valor de cada posição informada pelo usuário, você pode usar o laço for para pedir a leitura de cada uma das posições e outro laço para imprimir o vetor:

main()
{
    int var0[5], i;
    for(i = 0; i < 5; i++)
    {
        printf("Digite o valor da posicao %d: ",i+1);
        scanf("%d",&var0[i]);
    }
    for(i = 0; i < 5; i++)
        printf("Posicao %d: %d\n",i+1,var0[i]);
    system("pause");
}

Para vetores com muitas posições é extremamente inviável a impressão de cada posição de forma "manual".

Matrizes:
Vetores são também matrizes de uma dimensão.
Uma matriz de 2 dimensões pode ser declarada de forma parecida a de uma matriz de uma dimensão (vetor), porém, devemos informar a quantidade de linha e quantidade de coluna: int var0[2][3];

Atribuindo valores à matriz:
Para atribuir valores para uma matriz, devemos separar suas linhas por chaves ({}) e suas colunas por vírgula (,).
Exemplo:

int i, var0[2][3] = {
        {5,-8,3},
        {1,12,2} };

Podemos imaginar essa matriz da seguinte forma:

Posições	0	1	2
0	5	-8	3
1	1	12	2

Percorrendo uma matriz:
Para percorrer uma matriz bidimensional podemos usar dois laços de repetição. Um para percorrer as linhas e um para percorrer as colunas:

main()
{
    int i, j, var0[2][3] = {
        {5,-8,3},
        {1,12,2} };
    for(i = 0; i < 2; i++)
        for(j = 0; j < 3; j++)
            printf("Linha %d coluna %d: %d\n",i+1, j+1,var0[i][j]);
    system("pause");
}

Exemplo de código para percorrer a matriz pedindo os valores para o usuário:

main()
{
    int i, j, var0[2][3];
    for(i = 0; i < 2; i++)
    {
        for(j = 0; j < 3; j++)
        {
            printf("Digite o valor da Linha %d Coluna %d: ",i+1, j+1);
            scanf("%d",&var0[i][j]);
        }
    }
    for(i = 0; i < 2; i++)
    {
        for(j = 0; j < 3; j++)
        {
            printf(" %4d ",var0[i][j]);
        }
        printf("\n");
    }
    system("pause");
}