Funciones Asociadas al Manejo de cadenas

Strcpy: La función strcpy se encuentra en la biblioteca <string.h> y se

utiliza para copiar una cadena de caracteres (fuente) en el lugar que
ocupaba otra (destino). Esta copia es destructiva, o sea, que todos los
caracteres que estaban en la cadena destino desaparecen, aunque la
cadena destino fuera más larga que la cadena fuente .La cadena
destino se pone como primer argumento de la función y la cadena
fuente como segundo.

strcat: En el programa anterior vimos que la función strcpy es

desctructiva, pero hay otra función en la librería <string.h> que copia
una cadena (fuente) en otra (destino) sin destruir ésta, es decir, que
copia una cadena detrás de la otra esta función es conocida
como strcat.

strlen: esta función devuelve el total (entero) de caracteres que

conforman una cadena (excluyendo el carácter nulo \0).

strcmp: strcmp (abreviatura de ((string comparison))). La función

strcmp recibe dos cadenas, a y b, devuelve un entero. El entero que
resulta de efectuar la llamada strcmp(a, b) codifica el resultado de la
comparación:

Es menor que cero si la cadena a es menor que b,

Es 0 si la cadena a es igual que b, y

Es mayor que cero si la cadena a es mayor que b.

Naturalmente, menor significa que va delante en orden alfabético, y

mayor que va detrás.

isalnum(carácter): devuelve cierto (un entero cualquiera distinto de

cero) si carácter es una letra o dígito, y falso (el valor entero 0) en caso
contrario.

isalpha(carácter): devuelve cierto si carácter es una letra, y falso en

caso contrario.
isblank(carácter): devuelve cierto si carácter es un espacio en blanco
o un tabulador.

isdigit(carácter) devuelve cierto si carácter es un digito, y falso en

caso contrario.

isspace(carácter): devuelve cierto si carácter es un espacio en blanco,

un salto de línea, un retorno de carro, un tabulador, etc., y falso en
caso contrario.

islower(carácter): devuelve cierto si carácter es una letra minúscula, y

falso en caso contrario.

isupper(carácter): devuelve cierto si carácter es una letra mayúscula,

y falso en caso contrario.

toupper(carácter): devuelve la mayúscula asociada a carácter, si la

tiene; si no, devuelve el mismo carácter.

tolower(carácter): devuelve la minúscula asociada a carácter, si la

tiene; si no, devuelve el mismo carácter.

Nombre de la Descripción Errores de Sintaxis

Función
Strcpy La función strcpy se har ciudad[6];
encuentra en la
es posible escribir
biblioteca <string.h>
y se utiliza para En pseudocódigo:
copiar una cadena
de caracteres ciudad ← "Roma" (instrucción de
(fuente) en el lugar asignación)
que ocupaba otra
En lenguaje C:
(destino). Esta
copia es strcpy( ciudad, "Roma" ) (instrucción
destructiva, o sea, de expresión)
que todos los
caracteres que
estaban en la
cadena destino
 desaparecen,
aunque la cadena
destino fuera más
larga que la cadena
fuente .La cadena
destino se pone
como primer
argumento de la
función y la cadena
fuente como
segundo.
strcat En el programa
anterior vimos que cadena nombre = "Ana", apellido
= "Luz"
la función strcpy es
desctructiva, pero En lenguaje C:
hay otra función en
la char nombre[8] = "Ana",
librería <string.h> q apellido[4] = "Luz";
ue copia una
cadena (fuente) en
otra (destino) sin
destruir ésta, es
decir, que copia una
cadena detrás de la
otra esta función es
conocida
como strcat.

strlen Esta función longitud=strlen("hola")

devuelve el total printf("\nla longitud de la cadena
es:%s",longitud);
(entero) de
//longitud=4.
caracteres que
conforman una
cadena (excluyendo
el carácter nulo \0).
strcmp Strcmp (abreviatura #include <iostream>
using std::cout;
de ((string
using std::endl;
comparison))). La #include<cstring>
función strcmp int main()
 recibe dos cadenas, {
a y b, devuelve un char cadena1[] = "Hola A";
char cadena2[]="Hola Z";
entero. El entero
cout << "cadena1 es: " <<
que resulta de
cadena1 << endl;
efectuar la llamada cout << "cadena2 es: " <<
strcmp(a, b) codifica
cadena2 << endl;
el resultado de la cout <<
comparación. "strncmp(cadena1,cadena2,4)= "
<<
strncmp(cadena1,cadena2,4)<<e
ndl;
cout <<
Es menor que cero "strcmp(cadena1,cadena2)= " <<
si la cadena a es strcmp(cadena1,cadena2)<<endl;
menor que b, cout <<
"strcmp(cadena2,cadena1)= " <<
Es 0 si la cadena a strcmp(cadena2,cadena1)<<endl;
es igual que b, y

Es mayor que cero

si la cadena a es
mayor que b.

isalnum(carácte De vuelve cierto (un #include <stdio.h>

r) entero cualquiera #include <ctype.h>
distinto de cero) si
int main()
carácter es una letra { printf( "%sn%s%sn%s%snn", "De
o dígito, y falso (el acuerdo con isdigit: ",
valor entero 0) en isdigit( '8' ) ? "8 es un " : "8 no es un
caso contrario. ", "digito",
isdigit( '#' ) ? "# es un " : "# no es un
", "digito" );

printf(
"%sn%s%sn%s%sn%s%sn%s%snn", "
De acuerdo con isalpha:",
isalpha( 'A' ) ? "A es una " : "A no es
una ", "letra",
isalpha( 'b' ) ? "b es una " : "b no es
una ", "letra",
isalpha( '&' ) ? "& es una " : "& no es
 una ", "letra",
isalpha( '4' ) ? "4 es una " : "4 no es
una ", "letra" );
printf( "%sn%s%sn%s%sn%s%snn",
"De acuerdo con isalnum:",
isalnum( 'A' ) ? "A es un " : "A no es
un ",
"digito o una letra", isalnum( '8' )
? "8 es un " : "8 no es un ",
"digito o una letra",
isalnum( '#' ) ? "# es un " : "# no es
un ",
"digito o una letra" );
printf(
"%sn%s%sn%s%sn%s%sn%s%sn%s%sn",
"De acuerdo con isxdigit:",
isxdigit( 'F' ) ? "F es un " : "F no es un
",
"digito hexadecimal",
isxdigit( 'J' ) ? "J es un " : "J no es un
", "digito hexadecimal",
isxdigit( '7' ) ? "7 es un " : "7 no es un
",
"digito hexadecimal",
isxdigit( '$' ) ? "$ es un " : "$ no es un
",
"digito hexadecimal", isxdigit( 'f' )
? "f es un " : "f no es un ",
"digito hexadecimal" );

isalpha(carácte De vuelve cierto si

r) carácter es una
letra, y falso en caso
contrario.

isblank(carácte De vuelve cierto si

r) carácter es un
espacio en blanco o
un tabulador.

isdigit(carácte De vuelve cierto si

r) carácter es un digito,
 y falso en caso
contrario.

isspace(carácte De vuelve cierto si

r) carácter es un
espacio en blanco,
un salto de línea, un
retorno de carro, un
tabulador, etc., y
falso en caso
contrario.

islower(carácte De vuelve cierto si

r) carácter es una letra
minúscula, y falso en
caso contrario.

isupper(carácter De vuelve cierto si

) carácter es una letra
mayúscula, y falso en
caso contrario.

toupper(carácter De vuelve la
) mayúscula asociada a
carácter, si la tiene;
si no, devuelve el
mismo carácter.

tolower(carácter De vuelve la
) minúscula asociada a
carácter, si la tiene;
si no, devuelve el
mismo carácter.
 Ordenamiento Burbuja (Bubblesort)
Este es el algoritmo más sencillo probablemente. Ideal para empezar. Consiste en
ciclar repetidamente a través de la lista, comparando elementos adyacentes de
dos en dos. Si un elemento es mayor que el que está en la siguiente posición se
intercambian.

Algoritmo

for (i=1; i<TAM; i++)

2. for j=0 ; j<TAM - 1; j++)
3. if (lista[j] > lista[j+1])
4. temp = lista[j];
5. lista[j] = lista[j+1];
6. lista[j+1] = temp;

Vamos a ver un ejemplo. Esta es nuestra lista:

4-3-5-2-1
Tenemos 5 elementos. Es decir, TAM toma el valor 5. Comenzamos comparando el
primero con el segundo elemento. 4 es mayor que 3, así que intercambiamos. Ahora
tenemos:
3-4-5-2-1
Ahora comparamos el segundo con el tercero: 4 es menor que 5, así que no hacemos
nada. Continuamos con el tercero y el cuarto: 5 es mayor que 2. Intercambiamos y
obtenemos:
3-4-2-5-1
Comparamos el cuarto y el quinto: 5 es mayor que 1. Intercambiamos nuevamente:
3-4-2-1-5
Repitiendo este proceso vamos obteniendo los siguientes resultados:
3-2-1-4-5
2-1-3-4-5
1-2-3-4–5
 La 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.

Los siguientes artículos discuten cómo describir cuidadosamente

el algoritmo, cómo implementar el algoritmo en JavaScript y cómo
analizar su eficiencia.