Algoritmo de

burbuja

Conalep
FUNCION DESCRIPCION SINTAXIS
strcpy La función strcpy se #include <stdio.h>
#include <string.h>
encuentra en la
biblioteca <string.h> y
int main ()
se utiliza para copiar {
una cadena de char cad1[]= "Ser o no ser";
caracteres (fuente) char cad2[40];
en el lugar que char cad3[40];
ocupaba otra
(destino). Esta copia /* Copiar la cantidad máxima permitida por cad2 */
strncpy( cad2, cad1, 40 );
es destructiva, o sea,
que todos los /* copia parcial (solamente 5 chars): */
caracteres que strncpy( cad3, cad2, 5 );
estaban en la cadena cad3[5] = '\0'; /* caracter de fin de cadena agregado manua
destino desaparecen,
aunque la cadena puts( cad1 );
puts( cad2 );
destino fuera más puts( cad3 );
larga que la cadena
fuente .La cadena return 0;
destino se pone }
como primer
argumento de la
función y la cadena
fuente como
segundo.
Strcat En el programa #include <stdio.h>
#include <string.h>
anterior vimos que la
función strcpy es
int main ()
desctructiva, pero {
hay otra función en la char cad[80];
librería <string.h> que char cad2[] = "estan ";
copia una cadena
(fuente) en otra strcpy( cad, "estas " );
(destino) sin destruir
strcat( cad, "cadenas " );
ésta, es decir, que strcat( cad, cad2 );
copia una cadena strcat( cad, "concatenadas." );
detrás de la otra esta
función es conocida puts( cad );
como strcat.
return 0;
}
Strlen Esta función
#include <iostream>
devuelve el total #include <cstring>
(entero) de using namespace std;
caracteres que
conforman una int main() {
cadena (excluyendo char *cadena = "Una cadena C++ termina con cero";
el carácter nulo \0).
cout << "La cadena: [" << cadena << "] tiene "
<< {f:strlen}(cadena) << " caracteres" << endl;
return 0; }
strncat Concatena los
primeros "n" #include <stdio.h>
caracteres de una
cadena al final de #include <string.h>
otra.

int main () {

char src[50], dest[50];

strcpy(src, "This is source");

strcpy(dest, "This is destination");

strncat(dest, src, 15);

printf("Final destination string : |%s|", dest);

return(0);

strcmp Compara si dos #include <stdio.h>

#include <string.h>
cadenas son iguales
int main()
{
char s1[5] = "Abeja";
char s2[5] = "abeja";
int i;

printf( "s1=%s\t", s1 );
printf( "s2=%s\n", s2 );

i = strcmp( s1, s2 );
printf( "s1 es " );
if( i < 0 ) printf( "menor que" );
else if( i > 0 ) printf( "mayor que" );
else printf( "igual a" );
printf( " s2\n" );

return 0;}

strncmp Compara si los #include <stdio.h>

primeros "n" #include <string.h>
 caracteres de una
cadena son iguales a int main()
{
los primeros "n" char s1[9] = "artesano";
caracteres de otra. char s2[8] = "artista";
int i;

printf( "s1=%s\t", s1 );
printf( "s2=%s\n", s2 );

i = strncmp( s1, s2, 3 );

printf( "Las 3 primeras letras de s1 son " );
if( i < 0 ) printf( "menores que" );
else if( i > 0 ) printf( "mayores que" );
else printf( "iguales a" );
printf( " s2\n" );

return 0;
}

strchr Busca en la cadena

#include <stdio.h>
la primera ocurrencia #include <string.h>
de un caracter (char)
indicado. int main()
{
char s[11] = "Hola amigos";
char c = 'a';

printf( "s=%s\t", s );
printf( "c=%c\n", c );
printf( "strchr=%s\n", strchr( s, c ) );

return 0;
}

strrchr Busca en la cadena la

#include <stdio.h>
última ocurrencia de un
#include <string.h>
caracter (char) indicado.
int main()
{
char s[11] = "Hola amigos";
char c = 'a';

printf( "s=%s\t", s );
printf( "c=%c\n", c );
printf( "strrchr=%s\n", strrchr( s, c ) );

return 0;
}
strcspn Busca en una cadena
#include <stdio.h>
la primera ocurrencia de
#include <string.h>
cualquiera de los
caracteres de otra
int main()
cadena y retorna la
{
posición de la misma.
char s1[13] = "Hola a todos";
char s2[5] = "abcd";

printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strcspn(s1,s2) = %d\n", strcspn( s1, s2 ) );

return 0;
}

strpbrk Busca en una cadena

#include <stdio.h>
la primera ocurrencia de
#include <string.h>
cualquiera de los
caracteres de otra
int main()
cadena y retorna un
{
puntero a char con la
char s1[13] = "Hola a todos";
subcadena formada
char s2[5] = "deip";
desde esa posición.
printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strpbrk(s1,s2) = %s\n", strpbrk( s1, s2 ) );

return 0;
}

strspn Retorna el largo de la

porción inicial de una #include <stdio.h>
cadena que está #include <string.h>
formada solamente por
los caracteres presentes int main()
en otra. {
char s1[13] = "Hola a todos";
char s2[5] = "Hola";

printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strspn(s1,s2) = %d\n", strspn( s1, s2 ) );

return 0;
}

strstr Busca una cadena

dentro de otra cadena, #include <stdio.h>
retorna un puntero a la #include <string.h>
subcadena.
 int main()
{
char s1[13] = "Hola a todos";
char s2[3] = "la";

printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strstr(s1,s2) = %s\n", strstr( s1, s2 ) );

return 0;
}

strtok Divide una cadena en

segmentos (o tokens) #include <stdio.h>
delimitados por los #include <string.h>
caracteres char que
indiquemos. int main()
{
char s1[49] = "Esto es un ejemplo para usar la funcion strtok(
char s2[4] = " \n\t";
char *ptr;

printf( "s1=%s\n", s1 );

ptr = strtok( s1, s2 ); // Primera llamada => Primer token

printf( "%s\n", ptr );
while( (ptr = strtok( NULL, s2 )) != NULL ) // Posteriores
printf( "%s\n", ptr );

return 0;
}

strerror Retorna una cadena #include <stdio.h>

que describe un error
producido en el #include <string.h>
programa (pura
#include <errno.h>
magia).

int main ()
{
FILE *fp;

fp = fopen("file.txt","r");
if( fp == NULL )
{
 printf("Error: %s\n", strerror(errno));
}

return(0);
}

strlen Retorna el largo de

#include <iostream>
una cadena. #include <cstring>
using namespace std;

int main() {
char *cadena = "Una cadena C++ termina con cero";

cout << "La cadena: [" << cadena << "] tiene "
<< {f:strlen}(cadena) << " caracteres" << endl;
return 0;
}

strtok Divide una cadena en #include <stdio.h>

#include <string.h>
segmentos (o tokens)
delimitados por los int main()
caracteres char que { /* inicializa el arreglo de cadena */
indiquemos. char cadena[] = "Este es un enunciado con 7 tokens";
char *ptrToken; /* crea un apuntador char */

printf( "%sn%snn%sn", "La cadena a dividir en tokens es:", c

"Los tokens son:" );

ptrToken = strtok( cadena, " " ); /* comienza la división en t

enunciado */
/* continua la división en tokens hasta que ptrToken se hace
while ( ptrToken != NULL ) {
printf( "%sn", ptrToken );
ptrToken = strtok( NULL, " " ); /* obtiene el siguiente token
} /* fin de while */
return 0; /* indica terminación exitosa */

} /* fin de main */

strstr Busca una cadena #include <stdio.h>

#include <string.h>
dentro de otra
cadena, retorna un int main()
{
puntero a la char s1[13] = "Hola a todos";
subcadena. char s2[3] = "la";

printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strstr(s1,s2) = %s\n", strstr( s1, s2 ) );
 return 0;
}

strspn Retorna el largo de la

#include <stdio.h>
porción inicial de una #include <string.h>
cadena que está
formada solamente int main()
por los caracteres {
presentes en otra. char s1[13] = "Hola a todos";
char s2[5] = "Hola";

printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strspn(s1,s2) = %d\n", strspn( s1, s2 ) );

return 0;}

strpbrk Busca en una cadena #include <stdio.h>

#include <string.h>
la primera ocurrencia
de cualquiera de los int main()
{
caracteres de otra char s1[13] = "Hola a todos";
cadena y retorna un char s2[5] = "deip";
puntero a char con la printf( "s1=%s\n", s1 );
subcadena formada printf( "s2=%s\n", s2 );
desde esa posición printf( "strpbrk(s1,s2) = %s\n", strpbrk( s1, s2 ) );

return 0;
}

strcspn Busca en una cadena #include <stdio.h>

la primera ocurrencia #include <string.h>
de cualquiera de los
caracteres de otra int main()
cadena y retorna la {
posición de la char s1[13] = "Hola a todos";
misma. char s2[5] = "abcd";

printf( "s1=%s\n", s1 );
printf( "s2=%s\n", s2 );
printf( "strcspn(s1,s2) = %d\n", strcspn( s1, s2 ) );

return 0;
}
ALGORITMO DE BURBUJA
Este método consiste en comparar pares de elementos adyacentes e intercambiarlos entre si hasta
que todos se encuentren ordenados Se realizan (n-1) pasadas, transportando en cada de las mismas
el menor o mayor elemento (según sea el caso) a su posición ideal.

MÉTODO DE BURBUJA
(ORDENAMIENTO) CÓDIGO EN
C.
La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento.
Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente,
intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias
veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está
ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los
elementos durante los intercambios, como si fueran pequeñas "burbujas". También es
conocido como el método del intercambio directo. Dado que solo usa comparaciones para
operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de
implementar.

Aqui el codigo en C:

#include<stdio.h>
int main ()
{

int aux,i,j,k;
int n=10,A[n];

for (i=0; i<n; i++)

{
printf("dame el dato %dn",i+1);
scanf("%d",&A);
}
for (i=0;i<n;i++)
{
for (j=0;j<n-i;j++)
{
if (A[j]>=A[j+1])
{
aux=A[j];
A[j]=A[j+1];
A[j+1]=aux;
}

}
for (k=0;k<n;k++)
{
printf(" %d",A[k]);
}

return 0;
}

Búsqueda binaria

La búsqueda binaria es un algoritmo eficiente para encontrar un elemento

en una lista ordenada de elementos. Funciona al dividir repetidamente a
la mitad la porción de la lista que podría contener al elemento, hasta
reducir las ubicaciones posibles a solo una. Usamos la búsqueda binaria
en el juego de adivinar en la lección introductoria.

Una de las maneras más comunes de usar la búsqueda binaria es para

encontrar un elemento en un arreglo. Por ejemplo, el catálogo estelar
Tycho-2 contiene información acerca de las 2,539,913 estrellas más
brillantes en nuestra galaxia. Supón que quieres buscar en el catálogo una
estrella en particular, con base en el nombre de la estrella. Si el programa
examinara cada estrella en el catálogo estelar en orden empezando con la
primera, un algoritmo llamado búsqueda lineal, la computadora podría,
en el peor de los casos, tener que examinar todas las 2,539,913 de
estrellas para encontrar la estrella que estás buscando. Si el catálogo
estuviera ordenado alfabéticamente por nombres de estrellas, la búsqueda
binaria no tendría que examinar más de 22 estrellas, incluso en el peor de
los casos.

Pseudocódigo para la búsqueda binaria

Al describir un algoritmo para un ser humano, a menudo es suficiente
una descripción incompleta. Algunos detalles pueden quedar fuera de
una receta de un pastel; la receta supone que sabes cómo abrir el
refrigerador para sacar los huevos y que sabes cómo romper los huevos.
La gente puede saber intuitivamente cómo completar los detalles
faltantes, pero los programas de computadora no. Es por eso que
necesitamos describir completamente los algoritmos computacionales.

Para poder implementar un algoritmo en un lenguaje de programación,

necesitarás entender un algoritmo hasta sus últimos detalles. ¿Cuáles son
las entradas del problema? ¿Las salidas? ¿Qué variables deben crearse, y
qué valores iniciales deben tener?