//Ordena burbuja mejorado

#include <iostream>
using std::cout;
using std::cin;
using std::endl;
void mostrarArreglo(const int[], int); //prototipo de funcion que recibe
un arreglo constante
void ordenarArreglo(int[], int); //prototipo que modifica y ordena el
arreglo
void intercambiar(int&, int&); //prototipo, intercambialos valores de dos
elementos
int main()
{
const int tamano = 15;
int arreglo[tamano] = {8,10,9,14,1,2,12,15,11,5,6,7,3,4,13};
cout << "Arreglo antes de ordenarse: "
<<endl;
mostrarArreglo(arreglo,tamano);
cout << "Arreglo despues de ordenarse: " <<endl;
ordenarArreglo(arreglo,tamano);
mostrarArreglo(arreglo,tamano);
cout << "Fin del programa :)" << endl;
return 0;
}//fin de main
void mostrarArreglo(const int arreglo[], int tamano)
{
for (int i = 0 ; i < tamano ; i++)
cout << "arreglo["<< i << "]=" << arreglo[i]<< endl;
}
void ordenarArreglo(int arreglo[], int tamano)
{
int comparaciones = tamano;
bool termino = false;
for (int i = 0; i<(tamano-1) ; i++)
{
if (termino)
break;
termino = true;
for (int j = 0; j<comparaciones-1 ; j++)
if(arreglo[j] < arreglo[j+1])
{
intercambiar(arreglo[j],arreglo[j+1]);
termino = false;
}
comparaciones--;
}
}
void intercambiar(int &a, int &b)
{
int tmp = b;
b = a;
a = tmp;
}

Parmetros:
Se debe llamar a la funcin Quicksort desde donde quiera ejecutarse
sta llamar a colocar pivote para encontrar el valor del mismo
Se ejecutar el algoritmo Quicksort de forma recursiva a ambos lados del pivote
int colocar(int *v, int b, int t)
{
int i;
int pivote, valor_pivote;
int temp;

pivote = b;
valor_pivote = v[pivote];
for (i=b+1; i<=t; i++){
if (v[i] < valor_pivote){
pivote++;
temp=v[i];
v[i]=v[pivote];
v[pivote]=temp;

}
}
temp=v[b];
v[b]=v[pivote];
v[pivote]=temp;
return pivote;
}





void Quicksort(int* v, int b, int t)
{
int pivote;
if(b < t){
pivote=colocar(v, b, t);
Quicksort(v, b, pivote-1);
Quicksort(v, pivote+1, t);
}
}
Nota: Los tres parmetros de la llamada inicial a Quicksort sern array[0], 0, numero_elementos -1,
es decir, si es un array de 6 elementos array[0], 0, 5

Bsqueda primaria: Se utiliza cuando el vector en el que queremos determinar la existencia de un
elemento est previamente ordenado
C
int busquedaBinaria(int vector[], int n, int dato)
{
int centro,inf=0,sup=n-1;

while(inf<=sup){
centro=(sup+inf)/2;
if(vector[centro]==dato) return centro;
else if(dato < vector [centro] ){
sup=centro-1;
}
else {
inf=centro+1;
}
}
return -1;
}
C++
#include <iostream>
#include <vector>

bool busqueda_dicotomica(const vector<int> &v, int principio, int fin,
int &x){
bool res;
if(principio <= fin){
int m = (principio + fin)/2;
if(x < v[m]) res = busqueda_dicotomica(v, principio, m-1, x);
else if(x > v[m]) res = busqueda_dicotomica(v, m+1, fin, x);
else res = true;
}else res = false;
return res;
}
/*{Post: Si se encuentra devuelve true, sino false}*/

La criba de Eratstenes es un algoritmo que permite hallar todos los nmeros primos menores que
un nmero natural dado N. Se forma una tabla con todos los nmeros naturales comprendidos
entre 2 y N y se van tachando los nmeros que no son primos de la siguiente manera: cuando se
encuentra un nmero entero que no ha sido tachado, ese nmero es declarado primo, y se
procede a tachar todos sus mltiplos. El proceso termina cuando el cuadrado del mayor nmero
confirmado como primo es mayor que N.
En lenguaje C
void criba(unsigned char m[], int tam){
int i, h;

m[0] = 0;
m[1] = 0;
for(i = 2; i <= tam; ++i) m[i] = 1;

for(i = 2; i*i <= tam; ++i) {
if(m[i]) {
for(h = 2; i*h <= tam; ++h)
m[i*h] = 0;
}
}
}
En lenguaje C++
void criba(bool m[], int tam){
m[0] = false;
m[1] = false;
for(int i = 2; i <= tam; ++i) m[i] = true;

for(int i = 2; i*i <= tam; ++i) {
if(m[i]) {
for(int h = 2; i*h <= tam; ++h)
m[i*h] = false;
}
}
}

El algoritmo de Floyd-Warshall, es un algoritmo de anlisis sobre grafos para encontrar el camino mnimo en
grafos dirigidos ponderados. El algoritmo encuentra el camino entre todos los pares de vrtices en una nica
ejecucin. el algoritmo usa memoria cuadrtica. Hay que cuidar la inicializacin de las condiciones:
1 /* Suponemos que la funcin pesoArista devuelve el coste del camino que va de i a j
2 (infinito si no existe).
3 Tambin suponemos que es el nmero de vrtices y pesoArista(i,i) = 0
4 */
5
6 int camino[][];
7 /* Una matriz bidimensional. En cada paso del algoritmo, camino[i][j] es el camino mnimo
8 de i hasta j usando valores intermedios de (1..k-1). Cada camino[i][j] es inicializado a
9 pesoArista(i,j)
10 */
11
12 procedimiento FloydWarshall ()
13 para k: = 0 hasta n 1
14 para todo (i,j) en (0..n 1)
15 camino[i][j] = mn ( camino[i][j], camino[i][k]+camino[k][j])
16 fin para
17 fin para
// Declaraciones en el archivo .h
int cn; //cantidad de nodos
vector< vector<int> > ady; //matriz de adyacencia

// Devuelve una matriz con las distancias minimas de cada nodo al resto de los vertices.
vector< vector<int> > Grafo :: floydWarshall(){
vector< vector<int> > path = this->ady;

for(int i = 0; i < cn; i++)
path[i][i] = 0;

for(int k = 0; k < cn; k++)
for(int i = 0; i < cn; i++)
for(int j = 0; j < cn; j++){
int dt = path[i][k] + path[k][j];
if(path[i][j] > dt)
path[i][j] = dt;
}

return path;
}
Comportamiento con ciclos negativos
Para que haya coherencia numrica, Floyd-Warshall supone que no hay ciclos negativos (de hecho, entre cualquier
pareja de vrtices que forme parte de un ciclo negativo, el camino mnimo no est bien definido porque el camino
puede ser infinitamente pequeo). No obstante, si hay ciclos negativos, Floyd-Warshall puede ser usado para
detectarlos. Si ejecutamos el algoritmo una vez ms, algunos caminos pueden decrementarse pero no garantiza que,
entre todos los vrtices, caminos entre los cuales puedan ser infinitamente pequeos, el camino se reduzca. Si los
nmeros de la diagonal de la matriz de caminos son negativos, es condicin necesaria y suficiente para que este vrtice
pertenezca a un ciclo negativo.
//Determinantes
#include <stdio.h>
#define N 100
int sgn (int x);
int read_dim (int *dim);
int matrix_adj (int matrix[N][N], int matrix_aux[N][N], int dim, int m, int n);
int det_matrix_N (int matrix[N][N], int dim);
int det_matrix_adj (int matrix[N][N], int dim, int m, int n);

main() {
int i, j, dim, det, matrix[N][N];
while (!read_dim(&dim))
printf("Dimension no valida (<100).");
printf("\nIntroduzca elementos matriz...\n");
for (i=1; i<=dim; i++) {
printf("Elementos fila %d: ", i);
for (j=0; j<dim; j++)
scanf("%d", &matrix[i-1][j]);
}
if (dim!=1)
det=det_matrix_N(matrix,dim);
else
det=matrix[0][0];
printf("\nDeterminante = %d.\n\n", det);
}

int sgn (int x) {
if (x%2==0) return(1);
return(-1);
}
int read_dim (int *dim) {
int nl;
char aux;
printf("\nIntroduzca dimension matriz cuadrada (<100): ");
nl=scanf("%d", &(*dim));
if (nl!=1) {
scanf("%c", &aux);
while (aux!='\n')
scanf("%c", &aux);
}
if ( (*dim>=100) || (*dim<=0) )
return(0);
return(1);
}
int matrix_adj (int matrix[N][N], int matrix_aux[N][N], int dim, int m, int n) {
int i, j, p, q;
for (j=0, q=0; j<dim; j++)
if (j!=n) {
for (i=0, p=0; i<dim; i++)
if (i!=m) {
matrix_aux[p][q]=matrix[i][j];
p++;
}
q++;
}
return(dim-1);
}
int det_matrix_N (int matrix[N][N], int dim) {
int i, j, dim_aux, det;
for (i=0, j=0, det=0, dim_aux=dim; i<dim; i++)
det+=sgn(i+j)*matrix[i][j]*det_matrix_adj(matrix,dim_aux,i,j);
return(det);
}
int det_matrix_adj (int matrix[N][N], int dim, int m, int n) {
int matrix_aux[N][N];
if ( (matrix_adj(matrix,matrix_aux,dim,m,n)) == 1 )
return(matrix_aux[0][0]);
return(det_matrix_N(matrix_aux,dim-1));
}

//Matriz inversa
#include <iostream>
using namespace std;

int i,j, k, s;
float m1[1000][1000], coef, aux[1000], elemento;

int main()
{
cout << "tamao de la matrizn";
cin >> k;
for (i=0;i<k;i++)
{
for (j=0;j<k;j++)
{
cout << "Ingrese el valor de [" <<i<<"]["<<j<<"]";
cin >> m1 [i][j];
}
}
for (i=0;i<k;i++)
for(j=k;j<2*k;j++)
{
if(i==(j-k))
m1[i][j]=1;
else
m1[i][j]=0;
}
//Iteraciones
for (s=0;s<k;s++)
{
elemento=m1[s][s];
for (j=0;j<2*k;j++)
m1[s][j]=m1[s][j]/elemento;

for(i=0;i<k;i++)
{
if (i==s)
;
else
{
coef= m1[i][s];
for (j=0;j<2*k;j++)
aux[j]=m1[s][j]*(coef*-1);
for (j=0;j<2*k;j++)
m1[i][j]=m1[i][j]+aux[j];
}
}
}

}