Índex

Capítol 7

ELS VECTORS

Introducció a la noció de vector

Exercicis de vectors

Vectors de caràcters (cadenes o "strings")

Exercicis sobre vectors de caracters (strings)

Cerca d'informació en un vector

Cerca seqüencial.

Exercici de cerca sequencial.

Cerca dicotòmica. (o per dicotomies)

Ordenació d'un vector.

Ordenació per intercanvi directe o métode de la bombolla.

Exercicis amb ordenació i búsquedes

Ordenació per insercció directa.
Ordenació per selecció directa.

7.1. Introducció a la noció de vector

A continuació us introduiré una nova estructura de dades a la qual se li apliquen nombrosos tractaments iteratius : el vector.

Suposeu que tenim una empresa que té 40 sucursals i que cada final de mes es dedica a recollir les vendes que ha fet cadascuna d'aquestes sucursals i a sumar-les amb la finalitat d'obtenir el total de vendes netes al llarg del mes. Per emmagatzemar les vendes de les 40 sucursals dins el nostre programa la primera solució que se'ns acudiria seria declarar-nos 40 variables de tipus 'int', demanar els seus 40 valors i fer la suma de les quaranta variables immediatament després.

A la pràctica mai es fa servir una solució així, i el que es fa és agrupar tots els valors dins una variable de tipus vector.

Un vector és una variable composta, que pot emmagatzemar molts valors d'un mateix tipus. Però veiem un dibuix amb un exemple que pot ajudar-nos a entendre el que és un vector

Nom del vector: VendesSucursal
Lloc:	0	1	i...	39
Dada:	1000	2565	...	595
	VendesSucursal[0]	VendesSucursal[1]	VendesSucursal[i] ...	VendesSucursal[39]

En aquest cas la variable de tipus vector se'n diu VendesSucursal, i està com-posta de 40 posicions, cadascuna de les quals pot emmagatzemar un valor. Cadascu-na de les posicions del vector haurà d'emmagatzemar valors del mateix tipus. El primer valor emmagatzemat al vector l'anomenarem dins el programa per VendesSucursal [0] , el segon VendesSucursal [1] i així fins al darrer (en aquest cas fins a VendesSucursal [39]) . És a dir, mitjançant un índex tancat entre parèntesi, accedim als valors que composen el vector.

#include <stdio.h>
#define NRO_SUCURSALS 5 /*Dimensió del vector.*/

void main(void)
{
    /*Declaració d'un vector d'enters de NRO_SUCURSALS posicions*/
    int VendesSucursal[NRO_SUCURSA];
    int VendesTotals=0;
    int i;

    /*Introducció de les dades amb les vendes de les sucursals */
    for (i=0;i<NRO_SUCURSALS;i++)
    {
        printf("Introdueix les vendes de la sucursal %d ",i);
        scanf("%d",&VendesSucursal[i]);
    }

/*Procés de les dades (Suma de les vendes per calcular el total */
for (i=0;i<NRO_SUCURSALS;i++) VendesTotals = VendesTotals + VendesSucursal[i];

/* Escriptura del resultat */
printf("Les vendes totals han estat %d\n",VendesTotals);
}

7.1.1 Exercicis de vectors

Fer el mateix exercici de les sucursals suposant que tenim 10 sucursals.
Fer un programa per què et calculi el percentatge d'aprovats en una assignatura d'un vector on hi ha emmagatzemades les notes dels alumnes de la classe.
Feu un programa que calculi el sou anual net dels 10 empleats d'una empresa deduint del sou brut el IRPF i la SS. El percentatge que haurà de deduir en concepte de SS serà del 6% en tots el salaris. En concepte de IRPF el percentatge a treure serà variable, segon s'indica a continuació:

Límits del salari brut
IRPF
	salari <=	1400000	8%
1400000	< salari <=	1800000	11%
1800000	< salari <=	2200000	13%
2200000	< salari <=	3000000	17%
3000000	< salari <=	5000000	20%
5000000	< salari		25%

Afegiu el codi necessari perquè et calculi el salari mensual de cadascun dels empleats de l'empresa. Penseu que per obtenir això haureu de dividir entre 14 (12 mensualitats més dos pagues) el sou net anual.
Feu un programa que fent servir la funció rand(void) et trobi 16 números que estiguin entre 1 i 49. Al acabar el programa haurà de dir-te quants números han hagut de ser trets per rand per arribar a tenir els 16.
Feu un programa que emmagatzemi els diners de butxaca que tenen tots els alumnes de la classe, alumne per alumne i que després ens informi de quina és la quantitat més alta i la més petita que té un alumne.
Programa que demani les dates de naixement de tots els alumnes de la classe i ens digui qui és l'alumne més jove i el més vell. Les dates de naixement dels alumnes emmagatzemades a un vector de tipus long i hauran de tenir el format ddmmaaaa, on dd és el dia, mm el mes i aaaa és l'any.

7.2. Vectors de caràcters (cadenes o "strings")

També se'ls anomena cadenes o strings, i es tracta d'un vector que conté caràcters al seu interior. En aquest tipus de variables s'emmagatzemen les anomenades cadenes de caràcters o constants de caràcters. Per exemple, "Pere Martí", és una cadena o constant de caràcters, ja que és una seqüència de caràcters entre cometes dobles. A més té una amplada de 11 caràcters, els quals són els següents, Pere martí\0

Cal dir que el compilador de C afegeix dins el vector un caràcter '\0' que serveix per assenyalar la fi de la cadena. A més cal tenir en compte que l'espai en blanc també ocupa posició, així com qualsevol caràcter emmagatzemable dins una variable de tipus char.

String en C és un vector amb un codi ASCII \0 en darrer lloc
Vector Nom
P	e	r	e		M	a	r	í	\0
0	1	2	3	4	5	6	7	8	9

Exemple. Fem un programa que ens demana un nom i escriu els seus caràcters un a un dins un bucle for.

#include <stdio.h>
#include <string.h>

main()
{
    char nom[25];
    int i, llargada;
    printf("Escriu el teu nom: ");
    scanf("%s",nom);

/*Tractament de nom amb funcions predefinides de string*/
printf("El teu nom és %s\n",nom);

llargada=strlen(nom);
printf("Aquest nom té %d caràcters\n", llargada);

    /*Tractament de nom amb els elemnts de vector*/
    for(i=0; i<llargada;i++)
           printf("%c",nom[i]);

return 0;
}

També es convenient dir que si parlem de 'p' (amb cometes simples), estem parlant d'un caràcter i el compilador no coloca el caràcter '\0' al final. Així si per exemple tenim l'assignació,

caracter = 'c';

s'estarà emmagatzemant el codi ASCII del caràcter 'c' (el 99) en la posició de memòria on estigui definida la variable caracter.

Exemple:

Tenim un programa que llegeix de l'entrada caràcters fins que s'introdueix un punt. A més, a mida que s'introdueixen caràcters s'examina si el caràcter introduït és un dígit numèric ('0', '1', '2',...,'9') comptant el nombre de cadascun dels dígits que s'han introduït.

Per emmagatzemar el número de dígits de cada tipus que s'han introduït farem servir un vector. A la posició zero emmagatzemarem els números zeros que s'han introduït a l'entrada. A la posició 1, els 1 i així successivament.

/*10 dígits diferents al sistema decimal*/
#define NRO_DIGITS 10
#include <stdio.h>

void main(void)
{
/*Declaració d'un vector d'enters de 10 posicions*/
int digit[NRO_DIGITS];

int caracter, i, final;
int digitsIntroduits=0;

/*Inicialització de variables*/
for (i=0;i<NRO_DIGITS;i++) digit[i]=0;

    /*Entrada i tractament dels caràcters*/
    do
    {
       printf("Escriu un dígit: ");
       fflush(stdin);
       caracter=getchar();
       if (caracter>='0' && caracter<='9')
       {
          digit[caracter-'0'] = digit[caracter-'0'] + 1;
          digitsIntroduits = digitsIntroduits + 1;
       }
       final = (caracter=='.');
    } while (!final);

    /* Escriptura dels resultats per pantalla */
    printf ("dígits:\n");
    for (i=0; i<NRO_DIGITS; ++i)
           printf("%d %d\n",i,digit[i]);
    printf("no dígits %d\n",digitsIntroduits);
}

Per fer la crida a totes les funcions de string.h és necessari que els strings que es passin com paràmetres a les funcions tinguin el caràcter '\0' ficat al darrera.

Si tenim el vector,

char nom[45]

en ell podrem emmagatzemar cadenes de caràcters de com a màxim 44 elements (numerats des de la 0 fins a la 43), ja que el caràcter de final d'string '\0' ocupa una posició dins el vector.

Per assignar valor a les variables de tipus vectors de caràcters es fa la crida a la funció strcpy. Aquesta funció rep una cadena de caràcters d'entrada i treu de sortida un altre cadena de caràcters que és una còpia exacta de la que ha entrat. Per assignar una variable vector de caràcters fem,

strcpy ("Pere Martínez Ablanedo", nom)

i després de la crida tindrem emmagatzemat "Pere Martínez Ablanedo" a nom.

Un exemple de programa que fa servir cadenes de caràcters podria ser un programa que donat un vector de caràcters et compta el nombre de lletres 'a' que hi ha dins del vector i t'ho retorna.

#include <stdio.h>

int CuentaAs (char cadena[]);

void main()
{
char nom[45] ; /* Declaració d'un vector de 45 caràcters */
int numeroAsDelNom;

    /* Entrada de dades pel teclat */
    printf("Escriu el teu nom :");
    scanf ("%s", nom);

/* Procés de les dades (crida a CuentaAs) */
numeroAsDelNom = CuentaAs(nom);

    /* Escriptura del resultat per pantalla */
    if (numeroAsDelNom == 0)
        printf("El teu nom no en té cap de lletra a");
    else
        printf("El teu nom en té %d lletres a min£scules\n",numeroAsDelNom);
}

int CuentaAs (char cadena[])
{
    int final;
    int i=0;
    int asFinsAra=0;

    final = (cadena[i]=='\0');
    while (! final)
    {
        if (cadena[i] == 'a') asFinsAra++;
        i++;
        final = (cadena[i]=='\0');
    }

return asFinsAra;
}

En aquest cas tenim un vector que es passa com paràmetre a una funció.

Aleshores per permetre que el vector que arriba a la funció pugui tenir qualsevol mida, el que es fa és declarar el paràmetre amb la dimensió ( nombre de posicions del vector) buida. D'aquesta forma la dimensió es determinarà en temps d'execució de la funció i pot ser diferent a cadascuna de les crides que es fan a la funció. Al nostre exemple es fa la crida CuentaAs(nom);, així doncs en el moment que s'executi la funció CuentaAs, la dimensió de cadena passarà a ser 45, que és la dimensió de nom.

Si després cridéssim la funció strlen amb un altre vector, cadena passaria a tenir tants elements com el nou vector passat.

7.2.1. Exercicis sobre vectors de caracters (strings)

Feu un programa que et demani noms i et vagi escrivint el número de lletres 'a' que té cada nom introduït fins que se li introdueixi com a nom un return, és a dir la cadena buida "\0".
Feu un programa que endevini si tu i el teu company us dieu igual o no. Feu servir alguna funció de la llibreria string.h
Feu un programa que ens compti el número de grups 'la' que hi ha dins una frase.
Feu un programa al que se li introdueixi una frase i ens compti el número de lletres que hi ha dins de la frase.
Feu una funció que donat un nom ens retorni el mateix nom però amb les vocals en majúscules. Per això, feu servir la funció de la llibreria stdlib.h, toupper(c) que et retorna el caracter c en majúscules. Feu també un programa que faci la crida.
Feu una funció que donat un vector ens retorni el seu primer element. La declaració de la funció serà:

char primer?(cadena)

Feu una funció que donat un vector ens retorni el seu darrer element (compte! el '\0' no es considera el darrer element del vector, el darrer serà el que hi hagi tot just abans del '\0'). La declaració de la funció serà:

char darrer? (cadena)

Feu una funció que donat un vector de caràcters ens tregui el primer caràcter del vector i ens retorni el caràcter tret, així com el vector amb un element menys. La declaració de la funció serà:

char TreurePrimer(cadena)

Feu una funció que donat un vector de caràcters ens tregui el darrer caràcter del vector i ens retorni el caràcter tret, així com el vector amb un element menys. La declaració de la funció serà:

char TreureDarrer(cadena)

Feu un programa que donada una paraula en separi les seves vocals de les seves consonants. Per exemple si l'introduïm la paraula "carnestoltes", ens haurà de contestar que les vocals són "aeoe" i les consonants són "crnstlts".
Feu una funció que donat una cadena de caràcters i un índex (que representarà el lloc de la cadena on ens trobem) ens salti caràcters en blanc('\b'), tabuladors('\t') i caràcters de nova línia ('\n'). El programa ens retornarà un número que serà el lloc de la cadena on hi ha el següent caràcter diferent dels abans esmentats. Si s'assoleix el final de la cadena ('\0') , aleshores retornarà un -1. La declaració de la funció serà:

int saltar_espais(cadena,index)

Si la cridem per exemple amb els següents paràmetres, saltar_espais("La casa",2) ens haurà de retornar 3, que és el lloc de la cadena on comença la segona paraula.

Feu un programa compti el número de paraules que té una frase. Feu servir la funció d'abans anomenada saltar_espais.
Programa que ens retorni la paraula més llarga d'una frase introduïda.
Programar una funció reverse(s) que donada una cadena ens retorni la cadena inversa.

7.3. Cerca d'informació en un vector

7.3.1. Cerca seqüencial.

Hi ha vegades que volem saber si un determinat valor és a dins d'un vector. L'algorisme de cerca seqüencial busca l'element donat des del principi del vector mirant dins (és a dir el contingut) de cada posició del vector de manera seqüencial. I la condició de sortida de l'algorisme és en un d'aquests dos casos: - Quan haguem cercat en tot el vector.
- En trobar l'element que busquem, o bé

Funció cerca_sequencial

/*valor és l'element a cercar a dintre del vector.
v és el vector on tenim els valors on volem trobar el valor.*/

int cerca_sequencial (long v[], long tamany, long valor)
tamany és el llargària del vector. */
{
    long i;
    int trobat;
    i=0;
    trobat=FALSE;
    while ((i<=tamany-1) && !trobat)
    {
       trobat =(v[i]==valor);
       i++;
    };
    return trobat;
}

Exemple d'ús d'aquesta funció:

El següent programa llegeix pel teclat els 12 ingressos (mensuals) que ha tingut en Joan al llarg de l'any, després (i utilitzant la funció de cerca seqüencial a dintre del vector) cerca si Joan ha cobrat algun mes 115000 pessetes, finalment dóna un missatge informant del resultat obtingut.

Com utilitzar la funció cerca_sequencial

#include <stdio.h>

#define TRUE 1
#define FALSE 0
#define MAXIM 12 /* La grandària màxima del vector */

void main (void)
{
    long i, v[MAXIM], tamany, valor,trobat;
    tamany =12;
    for (i=0; i<=tamany-1;i++)
    {
       printf("Introdueix l'ingrés de Joan el més %ld :", i);
       scanf("%ld", &v[i]);
    }
    valor=115000;
    trobat = cerca_sequencial(v, tamany, valor);
    if (trobat)
       printf("En Joan algun mes ha cobrat %ld ptes.", valor);
    else
       printf("En Joan no ha cobrat cap mes %ld ptes.", valor);
}

7.3.1.1. Exercici de cerca sequencial:

Fer un programa que demani per teclat les següents dades

* Els ingressos que Joan ha rebut durant els dotze mesos de l'any. *
* La quantitat a cercar a dintre del vector. *

Com a resultat de la cerca el programa ens ha de dir si Joan ha rebut o no aquesta quantitat, i en cas positiu, ens digui en quin mes l'ha cobrat.

Nota: Haureu de modificar el resultat la funció de cerca seqüencial. Aquesta funció haurà de retornar el següent:

0:	Si no hem trobat l'ingrés a dintre del vector.
i+1 (el mes):	Si trobem l'ingrés a dins del vector.

7.3.2. Cerca dicotòmica. (o per dicotomies)

Pot passar que els valors del vector estiguin ordenats amb relació al criteri de cerca.

Si per exemple l'ordre és creixent tenim que:

v[k] <= v[k+1] , per tot valor de k.

El següent algorisme suposa que els valors del vector són ordenats de manera creixent. Divideix el vector en dues parts sensiblement iguals i per mig d'una comparació d'accés amb el valor de l'element del mig, elimina aquella de les dues parts que no pot contenir el valor cercat:

la part que precedeix l'element del mig, si l'element del mig és inferior al cercat, o la part que ve a continuació de l'element del mig si aquest és superior al element cercat.

La part no eliminada es torna a dividir en dos i així successivament fins trobat l'element o bé que la part no eliminada sigui d'un element.

/* valor és l'element a cercar a dintre del vector.
v és el vector on tenim els valors on volem trobar
el valor. tamany és la llargària del vector.
Nota: El vector donat ha de ser ordenat.*/

int CercaDicotomica(long v[], long tamany, long valor)
{
    long inf, sup, med;
    int trobat;
    trobat=FALSE;
    inf = 0;
    sup = tamany-1;
    while ((inf<=sup) && !trobat)
    {
       med = (sup+inf+1)/2;
       trobat =(v[med]==valor);
       if (valor < v[med])
          sup = med-1;
       else
          inf = med+1;
    };

return trobat;
}

Observem ara com es comporta aquesta funció amb tres casos ben diferents:

Cas A) Paràmetres: Valor = 63; Tamany=10;

V= 10 25 31 46 52 63 71 84 91 92

Pas 0:

inf =0; sup =9; med=5; trobat = true;

V= 10
inf 25 31 46 52 63
med 71 84 91 92
sup

Veiem que amb una sola iteració es capaç de trobar el valor buscat.

Cas B) Paràmetres: Valor = 31; Tamany=10;

V= 10 25 31 46 52 63 71 84 91 92

Pas 1:

inf =0; sup =9; med=5; trobat = false;

V= 10
inf 25 31 46 52 63
med 71 84 91 92
sup

Pas 2:

inf =0; sup =4; med=2; trobat = true;

V= 10
inf 25 31
med 46 52 sup 63 71 84 91 92

Veiem que amb dues iteracions ha estat capaç de trobar el valor buscat.

Cas C) Paràmetres: Valor = 100; Tamany=10;

V= 10 25 31 46 52 63 71 84 91 92

Pas 1:

inf =0; sup =9; med=5; trobat = false;

V= 10
inf 25 31 46 52 63
med 71 84 91 92
sup

Pas 2:

inf =6; sup =9; med=8; trobat = false;

V=
10 25 31 46 52 63 71
inf 84 91
med 92
sup

Pas 3:

inf =9; sup =9; med=9; trobat = false;

V= 10 25 31 46 52 63 71 84 91 92
inf,sup,med

Veiem que ha necessitat 3 iteracions per adonar-se que el valor a buscar no es a dintre del vector.

7.4. Ordenació d'un vector.

Hi ha vegades en què es convenient tenir un vector ordenat, per exemple en cas de voler aplicar-li posteriorment una cerca dicotòmica.

7.4.1. Ordenació per intercanvi directe o métode de la bombolla.

Aquest algorisme tracta posicions consecutives del vector de la següent manera : (v[1],v[2]),(v[2],v[3]),(v[3],v[4]), . . . , (v[tamany-2],v[tamany-1]).

Per cada element tractat (v[k],v[k+1]) s'intercanvien els seus valors si no són en ordre creixent.

Al final de la primera passada a tot el vector tenim en la posició més alta del vector el element més gran. Desprès es comença una segona passada sobre el subvector v(0..tamany-2) per a posar en la posició v[tamany-2] l'element més gran d'aquest subvector.

Pseudo codi per aquest problema: Per i := (tamany-1) fins a 1 fer
Mitjançant intercanvis successius en els parells (v[1],v[2]),(v[2],v[3]), (v[3],v[4]),. . . , (v[i-2],v[i-1]), portar l'element més gran a la posició v[i].
Fi per

Aquest algorisme amb el llenguatge C queda de la següent manera: void ordenacio_bombolla (long v[], long tamany)
{
    long i, k, aux;
    for (i=tamany-1;i>=1;i--)
       for (k=0;k<=i-1; k++)
          if (v[k]>v[k+1])
          {
             aux = v[k];
             v[k] = v[k+1];
             v[k+1] = aux;
          }
}

Observem com actua aquest algorisme sobre el següent vector:

*Posicions del vector*
	0	1	2	3	4	5	6
Estat inicial	23	10	75	5	37	49	53
Primer pas	10	23	5	37	49	53	75*
Segon pas	10	5	23	37	49	53*	75
Tercer pas	5	10	23	37	49*	53	75
Quart pas	5	10	23	37*	49	53	75
Cinquè pas	5	10	23*	37	49	53	75
Sisè pas (fi)	5	10*	23	37	49	53	75

Es veu clarament que en el tercer pas el vector ja és ordenat i en canvi nosaltres hem seguit efectuant tres passos més. Així la millora d'aquest algorisme consisteix en fer que aquest s'aturi en adonar-se de què el vector ja és ordenat. El següent algorisme incorpora una variable booleana on emmagatzemarem si durant el pas actual s'ha produït algun intercanvi de parelles.

Al finalitzar cada pas comprovarem la variable booleana i si aquesta ens diu que no em efectuat cap intercanvi vol dir que el vector ja és ordenat i per tant ja hem acabat.

La millora del mètode de la bombolla amb el llenguatge C queda de la següent manera:

/*v és el vector on tenim els valors a ordenar.
tamany és la llargària del vector.*/

void ordenacio_bombolla_millorada (long v[], long tamany)
{
    long i, k, aux;
    int intercanvi;
    intercanvi = TRUE;
    i=tamany-1;
    while ((i>=1) && intercanvi)
    {
       intercanvi = FALSE;
       for (k=0;k<=i-1;k++)
       if (v[k]>v[k+1])
       {
          aux = v[k];
          v[k] = v[k+1];
          v[k+1] = aux;
          intercanvi = TRUE;
       }
       i--;
    }
}

7.4.1.1 Exercicis amb ordenació i búsquedes

Programeu l'algorisme de cerca seqüencial, però que comenci a buscar per les posicions altes del vector i acabi per les posicions baixes.

Programeu una funció que demani 10 números (DIFERENTS) pel teclat i els emmagatzemi a dintre d'un vector de deu posicions. Haureu de comprovar que cada numero que l'usuari entri pel teclat no sigui ja a dintre del vector, per això haureu d'utilitzar la funció de cerca seqüencial.

Dissenya un programa que demani 10 números pel teclat, els emmagatzemi en un vector de deu posicions i finalment els ordeni i mostri per pantalla.

Dissenya un programa que demani els ingressos que en Joan i en Pere han tingut durant els dotze mesos de l'any (tenint en compte que ni en Joan ni en Pere poden cobrar la mateixa quantitat de pessetes en mesos diferents (com a l'exercici nº3) i els emmagatzemi i ordeni en dos vectors (un per Joan i l'altre per Pere). Una vegada ordenats i utilitzant la funció de cerca dicotòmica ens ha de dir quants de mesos en Joan i Pere han cobrat la mateixa quantitat.

Feu un algorisme que donat un vector inicial de 20 posicions ens retorni dos vectors. El primer vector haurà de tenir els deu primers números ordenats de menor a major. El segon vector haurà de tenir els deu darrers números ordenats també de menor a major.

Feu un algorisme que donats dos vectors inicials de 10 posicions ens retorni un vector ordenat de 20 posicions on siguin tots els valors dels dos vectors inicials.

Feu l'exercici nº 3, però ara, amb cerca dicotòmica. Cada nou valor haureu de comprovar que no és a dintre del conjunt de números que l'usuari ja ha teclejat. Ara a diferència de l'exercici nº 3, haureu d'insertar el nou valor en la correcta posició per tal de què no es desordeni el vector (NO podeu utilitzar cap funció d'ordenació de vectors).

Feu a ma els diferents passos que hauria de fer l'algorisme de cerca dicotòmica al buscar a dintre del vector (10, 25, 31, 46, 52, 63, 71, 84, 91, 92) els valors 84 i l'1.

Feu a ma els diferents passos que haurien de fer els algorismes d'ordenacio_bombolla i ordenacio_bombolla_millorada al dir-li que ordeni el vector (89, 4, 73, 100 ,49, 25, 1, 87, 12).

Feu el un algorisme d'ordenació diferent del de la bombolla a partir de la següent observació:

En tot moment el vector es compost de dues parts:

primera on tenim tots els elements ordenats
segona part on anem agafant d'un en un tots elements per anar posant-los ordenadament en la primera.

La solució es pot escriure així:

Per i de 1 fins a (tamany-1) fer
Insertar el valor de v[i] al lloc apropiat entre els valors de v(0..i-1)
Fi per

7.4.2. Ordenació per insercció directa.

Aquest algorisme es diu d'insercció perquè en la iteració i-èssima, inserim l'element i-èssim A[i] en el seu lloc correcte entre A[1],A[2], ....,A[i - 1], els quals ja han estat prèviament ordenats.

Després d'aquesta insercció, els elements A[1],A[2], ....,A[i] quedan ordenants.

La solució per un vector de: A[1],A[2], ....,A[N] posicions es pot escriure en pseudocodi així:

A[0] := -infinit;
Per i := 2 fins a N fer
    j := i;
    Mentre A[j]<A[j - 1] fer
       swap(A[j],A[j - 1]);
       j := j - 1;
    Fi mentre;
Fi per

7.4.3. Ordenació per selecció directa.

Funcionament de l'algorisme:

En el pas i-èssim seleccionem el contingut més petit, d'entre els A[i],..., A[N], i l'intercanviem (swap) amb A[i].

Com a resultat , després de i iteracions els i continguts més baixos ocupen les posicions A[1],...,A[i], de forma ordenanada.

La solució per un vector de: A[1],A[2], ....,A[N] posicions es pot escriure així:

Per i := 1 fins a N - 1 fer
    k := i;
    x := A[i];
    Per j := i + 1 fins a N fer
       Si A[j] < x llavors
          k := j;
          x := A[j];
       Fi si;
       A[k] := A[i];
       A[i] := x;
    Fi per;
Fi per;

Pseudo codi per aquest problema:	Per i := (tamany-1) fins a 1 fer Mitjançant intercanvis successius en els parells (v[1],v[2]),(v[2],v[3]), (v[3],v[4]),. . . , (v[i-2],v[i-1]), portar l'element més gran a la posició v[i]. Fi per
Aquest algorisme amb el llenguatge C queda de la següent manera:	void ordenacio_bombolla (long v[], long tamany) { long i, k, aux; for (i=tamany-1;i>=1;i--) for (k=0;k<=i-1; k++) if (v[k]>v[k+1]) { aux = v[k]; v[k] = v[k+1]; v[k+1] = aux; } }