PROGRAMACION

ORIENTADA A OBJETO

Ariadne Duron Rodríguez

Nombre de la función Descripción/para que sirve sintaxis
memcpy copia n bytes entre dos áreas char *strcat (char *dest,
de memoria que no deben const char *src)
solaparse
{

const char *p;

char *q;

for (q = dest; *q != '\0'; q++)

for(p = src; *p != '\0'; p++,

q++)

*q = *p;

*q = '\0';

return dest;

memmove copia n bytes entre dos áreas /* memmove example */

de memoria; al contrario
#include <stdio.h>
que memcpy las áreas pueden
solaparse #include <string.h>

int main ()

char str[] = "memmove can

be very useful......";

memmove (str+20,str+15,11);

puts (str);

return 0;

}
memchr busca un valor a partir de una void *memchr(const void *s,
dirección de memoria dada y int c, size_t n);
devuelve un puntero a la
primera ocurrencia del valor
buscado o NULL si no se
encuentra

memcmp compara los n primeros int memcmp(

caracteres de dos áreas de
const void *buf1,
memoria
const void *buf2,

size_t count

);

int wmemcmp(

const wchar_t * buf1,

const wchar_t * buf2,

size_t count

);

memset sobre escribe un área de #include <stdio.h>

memoria con un patrón de
#include <string.h>
bytes dado
int main()

char c = 'F';

char *s;

int i;

s=
(char*)malloc(5*sizeof(char));

memset( s, c, 5 );

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

printf( "c[%d]=%c ", i, c );

printf( "\n" );
 free(s);

return 0;

strcat añade una cadena al final de strcat( nombre, apellido )

otra

strncat añade los n primeros int main( )

caracteres de una cadena al
{
final de otra
char source[ ] = "
fresh2refresh" ;

char target[ ]= "C tutorial" ;

printf ( "\nSource string =

%s", source ) ;

printf ( "\nTarget string =

%s", target ) ;

strncat ( target, source, 5 ) ;

printf ( "\nTarget string after

strncat( ) = %s", target ) ;

strchr localiza un carácter en una char *strchr(const char

cadena, buscando desde el *cadena, int caracter);
principio

strrchr localiza un carácter en una

cadena, buscando desde el char *strrchr(const char
final *str, int c)

strcmp compara dos cadenas if (strcmp(str1,str2) == 0)

alfabéticamente ('a'!='A')
{

printf("Son iguales!.\n");

int strcmp(const char *

 s1,const char * s2, size_t
num);

strcoll compara dos cadenas según la

colación actual ('a'=='A')

strcpy copia una cadena en otra char *strcpy ( char *destino,

const char *origen );

strncpy copia los n primeros char *strncpy(char *dest,

caracteres de una cadena en const char *src, size_t n)
otra

strerror devuelve la cadena con el char *strerror(

mensaje de error int errnum
correspondiente al número de );
char *_strerror(
error dado const char
*strErrMsg
);
wchar_t * _wcserror(
int errnum
);
wchar_t * __wcserror(
const wchar_t
*strErrMsg
);

strlen devuelve la longitud de una #include<stdio.h>

cadena #include<string.h>
#include<stdlib.h>

main(){
char s[15]="Hola";
int n;

n = strlen(s);

printf("La cadena: \"%s\"

tiene %d caracteres.\n", s, n);

system("pause");
return 0;
}
strspn devuelve la posición del
primer carácter de una cadena size_t strspn(const char
que no coincide con ninguno *str1, const char *str2)
de los caracteres de otra
cadena dada

strcspn devuelve la posición del size_t strcspn(const char *s1,

primer carácter que coincide const char *s2);
con alguno de los caracteres
de otra cadena dada

strpbrk encuentra la primera char *strpbrk(const char *str1,

ocurrencia de alguno de los const char *str2)
caracteres de una cadena dada
en otra

strstr busca una cadena dentro de

otra char *strstr(const char
*haystack, const char
*needle)

strtok parte una cadena en una

secuencia de tokens char *strtok(char *str,
const char *delim)

strxfrm Transforma una cadena en su

forma de colación (??) size_t strxfrm(char
*dest, const char *src,
size_t n)

strrev invierte una cadena

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;
}
 BUSQUEDA BINARIA

En ciencias de la computación y matemáticas, la búsqueda binaria, también conocida como

búsqueda de intervalo medio1 o búsqueda logarítmica, es un algoritmo de búsqueda que
encuentra la posición de un valor en un array ordenado.

La búsqueda binaria es computada en el peor de los casos en un tiempo logarítmico, realizando

{\displaystyle O{\bigl (}\log n{\bigr )}} {\displaystyle O{\bigl (}\log n{\bigr )}} comparaciones, donde
n es el número de elementos del arreglo y log es el logaritmo. La búsqueda binaria requiere
solamente O(1) en espacio, es decir, que el espacio requerido por el algoritmo es el mismo para
cualquier cantidad de elementos en el array.5 Aunque estructuras de datos especializadas en la
búsqueda rápidas como las tablas hash pueden ser más eficientes, la búsqueda binaria se aplica a
un amplio rango de problemas de búsqueda.

ALGORITMO:

La búsqueda binaria funciona en arreglos ordenados. La búsqueda binaria comienza por comparar
el elemento del medio del arreglo con el valor buscado. Si el valor buscado es igual al elemento del
medio, su posición en el arreglo es retornada. Si el valor buscado es menor o mayor que el
elemento del medio, la búsqueda continua en la primera o segunda mitad, respectivamente,
dejando la otra mitad fuera de consideración.