__ Ordena��o de Dados __

- Processo bastante utilizado na constru��o de uma estrutura de dados.

- dados ordenados garamtem uma melhor pesquisa a uma ED.
Ex: _busca sequencial evita a varredura completa de uma lista de dados.

-ordena��o corresponde ao m�todo de rearranjar um conjunto de objetos em uma ordem

crescente e decrescente.
- tem como objetivo facilitar a recupera�ao dos itens do arquivo.
ex: _ recupera��o de nomes em uma lista telefonica.
- dados s�o mantidos em um vetor.

-Elementos do vetor
->objetos que possui um atributo chave que deve ser mantido ordenado.
->os registros s�o usados para representar os elementos a serem ordenados
tipoitem = record
chave: tipochave
{declara��es desejadas}
end,
-> um metodo troca (x,y) realiza a t roca dos elementos presentes nas posi��es x e
y do vetor.
-> para fins de exemplos, n�meros inteiros sera�o utilizados como elementos.

__ Classifica��o __

- Quanto a estabilidade:
- metodos instaveis: a ordem relativa dos itens com chaves iguais � alterada
durante o processo de ordena��o
- metodos est�veis: se a ordem relativa dos itens com chaves iguais mant�m-se
inalterada durante o processo.
- alguns dos m�todos de ordena��o mais eficientes n�o s�o est�veis.

-quanto ao conjunto de registros.

- ordena��o interna: o conjunto de registros cabe tudo em mem�ria principal
- ordena��o externa: o conjunto de registros n�o cabe completamente na
memoria principal e deve ser armazenado em disco
* alguns autores utilizam ordena��o de vetores(interna) e ordena�ao de
registros(externa)
* principail diferen�a: - interna: reg acessados diretamente
- externa: reg acessados sequencialmente ou em blocos.

__ M�todos de Ordena��o __

-> ordena��o por troca

-bubblesort(bolha)
-quicksort(troca e parti��o)
-> Ordena��o por inser��o
-insertonsort(m�todo de inser��o direta)
-binaryinsertionsort(inser��o binaria)
-> ordena��o por sele��o
-selectionsort(sele��o direta)
-headsort(arvore)
-> outros metodos
-mergesort(intercala��o)
-bucketsort(distribuidor de chave)

__ M�todos de Ordena��o simples __

-> s�o 3:
 -bubblesort
-insertionsort
-selectionsort

-> caracteristicas:
-facil implementa��o
- baixa complexidade
- compara��es ocorrem sempre entre posi�oes adjacentes do vetor.

___ Bubblesort ___

-> � um metodo simples de troca

- ordena atravez de sucessivas trocas entres pares de elementos do vetor.
-> caracteristicas:
- realiza varredur no vetor, trocando pares adjascentes de elementos, sempre
que o elemento for menor que o anterior.
- ap�s uma varredura o maior elemento est� corretamente posicionado no vetor
e n�o precisa mais ser comparado.
- ap�s a enesima varredura, os maiores elementos estar�o ordenados
- complexidade: para um vetor de n elementos, n-1 varreduras s�o feitas para
acertar todos elementos.
* numero de compara��es: (n-1) + (n-2)+... +2 + 1
* complexidade: (para qualquer caso: O(N�)

-> procedimento bubblesort para ordena��o de um vetor:

ProcBBSRT(var v: vetor, n : inteiro)

var i, j: inteiro;
x: tipoitem;

begin

for i := 2 to n do
for j:= n downto i do
begin
if v[j-1]> v[j] then
begin
x:=v[j-1];
v[j-1] := v[j];
v[j]:= x;
end;
end;
end;

___ Insertionsort___

-> � um metodo simples de inser��o.

-> caracteristicas:
- considera dois segmentos(sub-vetores) no vetor: odenado(aumenta) e n�o-
ordenado(diminui)
- ordena atraves da inser��o de um elemento por vez(1� elemento) do segmento
n�o ordenado no segmento ordenado, na posi��o correta
- inicialmente, o segmento ordenado cont�m o primeiro elemento no vetor
 - realiza uma busca sequencial no segmento ordenado para inserir corretamente
um elemento no segmento n�o-ordenado
- nesta busca, realiza trocas entre elementos adjacentes para ir acertando a
posi��o do elemento a ser inserido.

-> complexidade:
- pior caso: vetor totalmente desordenado O(n�)
- melhor caso: caso vetor j� ordenado O(n)

-> procedimento insertionsort para ordena��o de um vetor:

ProcINSSRT(var v: vetor, n: inteiro)

var i, j, k : inteiro
x:tipoitem;v

begin
for i:= 2 to n do
begin
x:=v[i];
j:= i-1;
while(x<=v[j])and(j>0) do
begin
v[j+1]:=v[j];
j:= j-1;
end;
v[j+1]:=x;
end;
end;

___ Selectionsort ___

-> � um metodo simples de sele��o

-> ordena atravez de sucessivas sele�oes do elemento de menor valor em um segmento

nao ordenado e seu posicionamento no
final de um segmento ordenado.

-> Caracteristicas:
-particular: realiza busca sequencial pelo menor valor no segmento nao
ordenado a cada intera��o.

-> complexidade:
-para qualquer uso O(n�).

PROCSelcSrt (var v:vetor, n:inteiro)

var i, j, k:inteiro;
x:tipoitem;

begin
for i=1 to n-1 do
begin
x:=i;
x:=v[i];
for j:=i+1 to n do
begin
if v[j] < x then
 begin
k:=j;
x:=v[j];
v[k]:=v[i];
end;
v[i]:=x;
end;
end;
end;

___ Metodo de orne��o de alta complexidade ___

-> merge sort
-> quick sort
-> hear sort

__ merge sort

-> � um algoritmo de ordena��o recursivo.

-> ele recursivamente ordena as duas metades do vetor.
-> usa a estrat�gia de divisao e conquista.
-> mege sort � um algoritmo eficiente
-> tem tempo de execu��o O(n log n).

__ m�todo de divis�o e conquista

divisao: divida o problema em duas ou mais partes, criando subproblemas menores.

conquista: os subproblemas usando divisao e conquista. caso os subproblemas sejam
sufientemente pequenos, resolva-os de forma direta.
combina: tome cada uma das partes e junte-os todas as formas a resolver o problema
original.

Listas encadeadas dinamicas

na representa��o por encadeamento acresenta-se a cada elemento da lista apontadores

que garantem a preced�ncia entre os elementos.

-Vantagens:
>inser��o e remo��o mais rapidas;
>uso mais racional da memoria dispon�vel;

-Desvantagens:

>"tamanho"(espa�o ocupado na mem�ria) de um elemento � maior do que o maior do que

o uso vaso por arranjo
> ruim para uma lista com poucos elementos

Listas encadeadas simples.

sequencia encadeada de elementos, chamados n�s da lista.

n� da lista � representado por dois campos

-a informa��o armazenadas e o ponteiro para o proximo elemento da lista
-a lista � representada por um ponteiro para o primeiro n�.
-o ponteiro do ultimo elemento � NULL

plista prox prox =====

|______| --> |_INFO_||___|------> |_INFO_||___|-----> ===
=

ex:
- lista encadeada armazenando valores inteiros;
- extrutura lista
- tipo lista
- tipo dos n�s da lista.

struct lista{
int info;
strutct lista *prox;
};

typedef strutct lista lista;

Lista � uma estrutura autoreferenciada pois o campo prox � um ponteiro para a

proxima
estrutura do mesmo tipo.

uma lista encadeada � representada pelo ponteiro para seu primeiro elemento,
do tipo lista*

OPERA��ES

->de fun��o do tipo em c

typedef struct{
int info;
node *prox;
} node;

-> declara��o do apontador para a lista

node *plista;
CriarListaSimples (node*plista)
{
plista=null;
}

INSER��O
- aloca memoria para apontar o elemento
- encadeia o elemento na lista existente

|_INFO1_| --> |_INFO2_| --> |_INFO3_|---

-
-
\/

InsereNoInicioLista (int.elem)
{
 node *aux;
aux=(node*) malloc (sizeoff(node));
*aux.info=elem;
*aux.prox=plista
plista=aux;
aux=null;
}

InsereNoFinalDaLista(int.elem)
{
node *aux1, *aux2;
aux1=(int*) malloc (sizeoff(int));
*aux1.info=elem;
*aux1.prox=null;
if (plista != null)
{
aux2=plista;
while (*aux2.prox != null)
aux2 = *aux2.prox;
*aux2.prox = aux1;
9 aux2=*aux1=null;
}
else
plista=aux1;
aux1=null;
}

RemoveDoInicioLista
{
node *aux;
] if (plista==null)
"Lista vazia"
else
aux=plista;
plista=plista.prox;
free(aux);
aux=null;
}

MostraElementosLista()
{
node*aux;
if(plista != NULL)
{
aux= plista;
do{
printf("%d", aux.into);
aux=*aux.rpox,
} while (aux != null);
}
}

LISTA CIRCULAR SIMPLES

essa representa��o � uma modifica��o da
lista simples, ondeo �ltimo elemento
aponta para o primeiro.
|_INFO_|
-
-
\/
prox prox
|_INFO_| --> |_INFO_|......--> |_INFO_|
- -
- -
----------------------------------

LISTA COM SENTINELA

essa representa��o � uma modifica��o
da lista simples onde existe um elemento
(primeiro n� auxiliar)

um n� sentinela (n� cabe�a) � um n� no

qual o conte�do do seu campo de informa��o
n�o � considerado como pertencente a lista,
podendo ser usado para armazenar informa��es
a fim de simplificar alguns algoritioms (por exemplo,
tal n� poderia armazenar o tamanho corrente da lista).

Sua principal finalidade � evitar o casdo de listas vazias

com apontadores nulos, especialmente no caso de listas circulares.

|_PLISTA_|
-
-
\/
sent
|___| --> |_INFO_|......-->|_INFO_|
-
-
\/

\\03-07-17

LISTA DUPLAMENTE ENCADEADA

-cada elemento tem um ponteiro para o pr�ximo elemento

e um ponteiro para o elemento anterior.

-dado um elemento, � possivel acessar o pr�ximo e o anterior.

-dado um ponteiro para o �ltimo elemento

da lista, � possivel percorrer a lista em ordem inversa.

|_PLISTA_|
-
-
\/
ant prox ant prox ant prox
|_INFO_|<---->|_INFO_|<......>|_INFO_|
- -
- -
 \/ \/

ESTRUTURA PARA IMPLEMENTA��O

struct lista2{
int info;
struct lista2 *aut;
strict lista2 *prox;
};