Bubble Sort

Um algoritmo de busca bem simples que irá buscar posições dentro do array, se a condição imposta for verdadeira, ela troca os elementos entre si.

bubble_sort.py

# Importando Sys
import sys

# Definindo Main
def main():

# Usuário irá digitar uma array int e o
# bubble sort irá buscar e organizar.

    print('Bubble Sort')
    print('Digite uma array com espaços  | Ex: 12 23 4 6 21 13')
    print('-------------------------------------------------------------------')
    array = list(map(int,input().split()))
    bubble_sort(array)

    print('Array organizado de forma crescente: ', array)
   
# Função bubble sort irá organizar o array
# Ele atravessa o array entre 0 e (qtderegistros)-i-1, troca o elemento
# se mesmo for maior que o próximo.
def bubble_sort(array):
# Carrega array_len com o valor do numero de registro que o mesmo persiste.
    array_len = len(array)

    for i in range(array_len):
# Quando a condição for verdade, os elementos trocam entre si de posição
        for j in range(0, (array_len-i)-1):
            if array[j] >> array[j+1]:
                array[j], array[j+1] = array[j+1], array


# Primeira call será a main
if __name__ == '__main__':
    main()

Selection Sort

Nesse exemplo, iremos usar a técnica de Selection Sort, esse algoritmo irá comparar todos os valores da array, e enviar o menor valor para o inicio.

Select_sort.py

# Importando Sys
import sys

# Definindo Main
def main():

# Usuário irá digitar uma array int e o
# select sort irá buscar e organizar.

    print('Selection Sort')
    print('Digite uma array com espaços  | Ex: 12 23 4 6 21 13')
    print('-------------------------------------------------------------------')
    array = list(map(int,input().split()))
    select_sort(array)

    print('Array organizado de forma crescente: ', array)
   


# Função select sort irá organizar o array
# Ele comprara os valores e o menor vai para o inicio do array
def select_sort(array):
    for i in range(len(array)):
        min_index = i
        for j in range(i+1, len(array)):
            if array[min_index] > array[j]:
                min_index = j

# Se o valor for menor, irá inserir no começo do array
        array[i], array[min_index] = array[min_index], array[i]



# Primeira call será a main
if __name__ == '__main__':
    main()

Insert Sort

O usuário fornece um array de forma não organizada, e a função insert_sort irá organizar de forma crescente.

insert_sort.py

import sys

# Definindo Main
def main():

# Usuário irá digitar uma array int e a função
# Insert Sort irá ordenar de forma crescente.
    print('Insert Sort')
    print('Digite uma array com espaços | Ex: 32 23 13 12 22 33')
    print('-------------------------------------------------------------------')
    array = list(map(int,input().split()))
    insert_sort(array) 
    print ("Array organizado de forma crescente:") 
    print(array)

def insert_sort(array):
    for i in range(0, len(array)):
        chave = array[i]
        j = i-1
        while j >= 0 and chave < array[j]:
            array[j+1] = array[j]
            j -= 1
        array[j+1] = chave

# Primeira call será a main
if __name__ == '__main__':
    main()

Meter – Tratamento e busca em arrays.

Segue um projeto que utiliza vários sistemas de buscas escrito em C.

METER.C

// Bibliotecas:
//	
//  interface = métodos para interface-usuário.

#include "stdio.h"
#include "stdlib.h"
#include "interface.h"
#include "time.h"
#include "strings.h"

// Capacidade total de numeros de Residencia
#define MAXRES 1000

// Estrutura que comportará informações sobre nome da rua (char25), numero da casa(int), n do medidor(int), e o consumo(float) da Residencia.

struct Residence {
	char street[10];
	int nHouse;
	int nMeter;
	float nMeasure;
} vecResidences[MAXRES]; 

// Selecionará qual tipo de busca será realizada
int opSearch = 0;

// Método de apoio ao Merge sort que intercala as arrays
void merged(int p,int q,int r){
	int i,j,k;
	float *w;
	
	w =  malloc((r-p)*sizeof(float));
	i = p;
	j = q;
	k = 0;
	
	while(i< q && j < r){
		if(vecResidences[i].nMeasure <= vecResidences[j].nMeasure)
		w[k++] = vecResidences[i++].nMeasure;
		else
		w[k++] = vecResidences[j++].nMeasure;
	}

	while(i<q) w[k++] = vecResidences[i++].nMeasure;
	while(j<r) w[k++] = vecResidences[j++].nMeasure;
	
	for(i=p;i<r;i++) vecResidences[i].nMeasure = w[i-p];
	free(w);
}

// Método de apoio ao Merge sort que intercala as arrays
void merge(int p,int q,int r){
	int i,j,k;
	float *w;
	
	w =  malloc((r-p)*sizeof(float));
	i = p;
	j = q;
	k = 0;
	
	while(i< q && j < r){
		if(vecResidences[i].nMeasure > vecResidences[j].nMeasure)
		w[k++] = vecResidences[i++].nMeasure;
		else
		w[k++] = vecResidences[j++].nMeasure;
	}

	while(i<q) w[k++] = vecResidences[i++].nMeasure;
	while(j<r) w[k++] = vecResidences[j++].nMeasure;
	
	for(i=p;i<r;i++) vecResidences[i].nMeasure = w[i-p];
	free(w);
}


// Metodo Merge Sort, divide os arrays no meio

void mergeSort(int p, int r){
	
	if(p < r-1){
		int q = (p+r)/2;
		mergeSort(p,q);
		mergeSort(q,r);
		merge(p,q,r);
	}
	
}

// Metodo Merge Sort, em modo decrescente

void mergeSortd(int p, int r){
	
	if(p < r-1){
		int q = (p+r)/2;
		mergeSort(p,q);
		mergeSort(q,r);
		merged(p,q,r);
	}
	
}

//Metodo Insert Sort
int insertSort(int typeP){
	int i,j;
	float x;
	
	if(typeP==1){
		
	for(j=1;i<MAXRES;j++){
		x = vecResidences[j].nMeasure;
		i=j-1;
		
		while((i>=0) && (vecResidences[i].nMeasure > x)){
			vecResidences[i+1].nMeasure = vecResidences[i].nMeasure;
			i=i-1;
		}
			vecResidences[i+1].nMeasure = x;
	}
	} else {
	for(j=1;i<MAXRES;j++){
		x = vecResidences[j].nMeasure;
		i=j-1;
		
		while((i>=0) && (vecResidences[i].nMeasure < x)){
			vecResidences[i+1].nMeasure = vecResidences[i].nMeasure;
			i=i-1;
		}
			vecResidences[i+1].nMeasure = x;
	}
	}
		
	
	return 1;
}



int bubbleSort(int typeP){
	int x=0,y =0;
	float aux;
	
	if(typeP == 1){
		for(x=0;x<MAXRES;x++){
			for(y=x+1;y<MAXRES;y++){
				if(vecResidences[x].nMeasure > vecResidences[y].nMeasure){
					aux = vecResidences[x].nMeasure;
					vecResidences[x].nMeasure = vecResidences[y].nMeasure;
					vecResidences[y].nMeasure = aux;
				}
			}
		}
    } else {
		for(x=0;x<MAXRES;x++){
			for(y=x+1;y<MAXRES;y++){
				if(vecResidences[x].nMeasure < vecResidences[y].nMeasure){
					aux = vecResidences[x].nMeasure;
					vecResidences[x].nMeasure = vecResidences[y].nMeasure;
					vecResidences[y].nMeasure = aux;
				}
			}
		}
	}
	return 1;
}




// Metodo select Sort
int selectSort(int typeP){
	float menor, temp;
	int i=0,z=0;
	
	
	if(typeP == 1){
		
	while(i<MAXRES){
		menor = vecResidences[i].nMeasure;
		z = i+1;
			while(z<MAXRES){
				if(vecResidences[z].nMeasure < menor){
					temp = vecResidences[z].nMeasure;
					vecResidences[z].nMeasure = menor;
					menor = temp;
				}
				z++;
			}
			vecResidences[i].nMeasure = menor;
			i++;		
	} } else {
	
	while(i<MAXRES){
		menor = vecResidences[i].nMeasure;
		z = i+1;
			while(z<MAXRES){
				if(vecResidences[z].nMeasure > menor){
					temp = vecResidences[z].nMeasure;
					vecResidences[z].nMeasure = menor;
					menor = temp;
				}
				z++;
			}
			vecResidences[i].nMeasure = menor;
			i++;		
	}	

	}
	return 1;
}


// Inicia a processamento da estrutura
int procStruct(int opS, int typeP){
	
	int error=0;
	
	switch (opS){
		case 1:
			error = selectSort(typeP);
			if(error != 1){
			printf("Erro ao processar SelectSort\n");
			system("PAUSE>null");
			}
			break;
		case 2:
			error = bubbleSort(typeP);
			if(error != 1){
			printf("Erro ao processar SelectSort\n");
			system("PAUSE>null");
			}
			break;
		case 3:
			error = insertSort(typeP);
			if(error != 1){
			printf("Erro ao processar InsertSort\n");
			system("PAUSE>null");
			}
			break;
		case 4:
			if(typeP = 1)
			mergeSort(0,MAXRES);
			else
			mergeSortd(0,MAXRES);
			break;
		default:
			printf("Processo nao concluido\n");
			system("PAUSE>null");
		
	}
	return 1;
}

// Inicia a array 
int startArray(struct Residence *vec){
	int i;
	
	for(i=0;i<MAXRES;i++){
	vec[i].nHouse = rand() % 1000;	
	vec[i].nMeter = rand() % 100;
	vec[i].nMeasure = (float)(rand() % 1000);
	
	}
		
return 1;
}

int main (){
	int i = 0, opt = 0, opS = 1;
	char opM;
	
	int error = startArray(vecResidences);
	if (error != 1){
		printf("Erro ao popular Array\n");
	}
	
	while (opt == 0){
	error = interfaceM(0, opS);
		
	if (error != 0)
		printf("Erro ao iniciar interface\n");
		
	fflush(stdin);	
	opM = getch();


	// Switch das opcoes apresentadas no User Interface.	
		switch (opM) { 
			case '1':
				error = 0;
				error = procStruct(opS, 1);
				opt = 1;
				if(error != 1)
					printf("Erro a processar Array em ordem crescente\n");
				break;
			case '2':
				error = 0;
				error = procStruct(opS, 2);
				opt = 1;
				if(error != 1)
					printf("Erro a processar Array em ordem decrescente\n");
				break;
			case 'A':
				opS = opS + 1;
				if(opS >= 5){
					opS = 1;
				}
				break;
			default: break;
		}

    }
	
	for(i=0;i<MAXRES;i++){
	printf("\n Rua Teste | %4d | %3d | %4.2f \n", vecResidences[i].nHouse, vecResidences[i].nMeter
									, vecResidences[i].nMeasure);
	}
	
	system("PAUSE>null");
	
	return 1;
}

Interface.h

int interfaceM(int, int);


int interfaceM(int op, int opSe){
	
	system("cls");
	printf("------------------------------------------------------- Meter.c ---------\n");
	printf("\n");
	printf("\n");
	if (opSe == 1)
	printf(" |Selecao e Troca| - Distribuicao - Insercao - Intercalacao              \n");
	if (opSe == 2)
	printf(" Selecao e Troca - |Distribuicao| - Insercao - Intercalacao              \n");
	if (opSe == 3)
	printf(" Selecao e Troca - Distribuicao - |Insercao| - Intercalacao              \n");
	if (opSe == 4)
	printf(" Selecao e Troca - Distribuicao - Insercao - |Intercalacao|              \n");
	printf("\n");
	printf("A: para alternar metodo de busca.\n");
	printf("------------------------------------------------------- Meter.c ---------\n");
	printf("\n");
	printf(" 1- Ordenacao Crescente\n");
	printf(" 2- Ordenacao Decrescente\n");
	printf("\n");
	
	return 0;
		
	
}

Exemplo

Aplicações em C – QuickSort

Em minhas aulas de c, deparei com esse algoritmo muito importante, que trabalha de forma recursiva e ordena uma cadeia de array. Ele é considerado um dos mais populares, QuickSort, literalmente, ele vai dividindo o array pelo meio, e o resto pelo meio e assim por diante, a interface está horrível porque a intensão esta no algoritmo.

Link para download: AQUI

[]´s