Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Integrantes:
Aguirre Miguel
Cedeo Wilna
Hidalgo Solmaira
Julia Figueroa
Orozco Iris
Torres Garykel
SINTAXIS
La palabra sintaxis proviene del trmino en latn syntaxis, que a su vez
deriva de un vocablo griego que se traduce al espaol como coordinar. Se trata
de la rama de la gramtica que ofrece pautas creadas para saber cmo unir y
relacionar palabras a fin de elaborar oraciones y expresar conceptos de modo
coherente. En la informtica, la sintaxis se entiende como el grupo de normas que
marcan las secuencias correctas de los elementos propios de un lenguaje de
programacin.
LISTAS
Las listas al igual que las pilas y las colas, son una estructura de datos de
tipo lineal diferencindose de las anteriores en el hecho de que pueden las
inserciones y eliminaciones se en cualquier parte de la lista. Esto hace que tengan
mayor aplicabilidad en el entorno real. Se abordan los temas relacionados con los
conceptos bsicos de las listas, as como tipos de listas y las operaciones que se
pueden realizar con las listas, todo conjugado en programas de aplicacin,
implementados con apuntadores.
Se hace uso de un men de opciones para cada programa y funciones para la
insercin, visualizacin, eliminacin y bsqueda de nodos en la lista. Al igual que
en los anteriores captulos, cada uno de los programas aqu presentados, estn
previamente compilados y depurados de tal manera que se mustra la salida en
pantalla de cada uno. Lo anterior garantiza al estudiante que puede guiarse en el
cdigo fuente para hacerle modificaciones y proponer soluciones a entornos
reales.
CONCEPTOS BSICOS DE LISTAS
Una lista enlazada es una coleccin o secuencia de elementos del mismo
tipo dispuestos uno detrs de otro, en el que cada elemento se liga al siguiente
elemento por un enlace que no es ms que un puntero previamente definido.
Las listas segn su estructura se han dividido en cuatro grandes categoras:
1.- Listas Simplemente enlazadas
2.- Listas Doblemente enlazadas
3.- Listas Circular simplemente enlazada
4.- Lista circular doblemente enlazada
LISTA SIMPLEMENTE ENLAZADA
Entre las listas simplemente enlazadas se encuentra un tipo de lista con
poca aplicabilidad llamada Lista contigua:
LISTA CONTIGUA
Es un tipo especial de lista lineal, la cual se compone de un conjunto de
elementos de un tipo dado que se encuentran ordenados y pueden variar en
nmero. Esta es una definicin general, que incluye los ficheros y vectores.
Las entradas de una gua o directorio telefnico, por ejemplo, estn en lneas
sucesivas, excepto en las partes superior e inferior de cada columna. Una lista
lineal se almacena en la memoria principal de una computadora en posiciones
LISTAS ENLAZADAS
Las listas enlazadas o de almacenamiento enlazado son mucho ms
flexibles y potentes, su uso es mucho ms amplio comparado con la lista contigua.
Una lista enlazada o encadenada es un conjunto de elementos del mismo tipo en
los que cada elemento contiene la posicin o direccin del siguiente elemento de
la lista. Cada elemento de la lista enlazada debe tener al menos dos campos: un
campo que tiene el valor del elemento y un campo (enlace, link) que contiene la
OPERACIN DE BORRADO:
La operacin de borrado consiste en eliminar un elemento de la lista,
considerando que se debe redefinir los enlaces involucrados en la operacin. Se
pueden presentar cuatro casos bsicos:
Eliminar el primer elemento de la lista.
Eliminar el ltimo elemento de la lista.
Eliminar de la lista un elemento especfico, es decir, que tenga cierta
informacin.
Eliminar de la lista el elemento anterior o posterior al elemento que tiene
cierta informacin.
IMPLEMENTACIN DE UNA LISTA ENLAZADA CON PUNTEROS
El siguiente programa se plantea como ejemplo gua para implementar una
lista simplemente enlazada con punteros, para gestionar nmeros enteros,
ingresados por teclado con funciones de crear, insertar, eliminar, recorrer y buscar.
Las eliminaciones y la bsqueda, se realizan en cualquier lugar de la lista.
Progra29.cpp
#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
struct lista
{
int dato;
struct lista *sig;
};
void crear(struct lista **);
void insertar(struct lista **, int);
void eliminar(struct lista **, int);
void recorrer(struct lista **);
int buscar(struct lista **, int);
int main()
{
clrscr();
struct lista *entero;
int dato;
crear(&entero);
cout<<"OPERACIONES CON LA LISTA ENLAZADA\n\n ";
cout<<"Para finalizar la insercion Ingrese el cero\n\n ";
cout<<"Ingrese un numero: ";
cin>>dato;
while(dato != 0)
{
insertar(&entero, dato);
cout<<"Ingrese un numero: ";
cin>>dato;
}
cout<<"\n \n ELEMENTOS DE LA LISTA \n\n";
recorrer(&entero);
cout<<"\n \n Ingrese el numero a eliminar: ";
cin>>dato;
eliminar(&entero, dato);
recorrer(&entero);
cout<<"\n \n Ingrese el numero a buscar: ";
cin>>dato;
if(buscar(&entero,dato) == 1)
cout<<"\n El numero "<<<" fue encontrado\n";
else
cout<<"Enl numero no existe "<
getchar();
return 0;
}
// funciones de listas simplemente enlazadas
void crear(struct lista **entero)
{
*entero = NULL;
}
void insertar(struct lista **entero, int dato)
{
struct lista *auxiliar, *puntero, *anterior;
auxiliar = new lista;
if(!auxiliar)
{
cout<<"error:memoria insuficiente"<
exit(1);
}
auxiliar->dato = dato;
anterior = NULL;
puntero = *entero; //puntero es el puntero auxiliar que recorre la lista
while((puntero != NULL) && (puntero->dato < dato))
{
anterior = puntero;
puntero = puntero->sig;
}
if(anterior == NULL)
{
auxiliar->sig = *entero;
*entero = auxiliar;
}
else
{
anterior->sig = auxiliar;
auxiliar->sig = puntero;
}
}
void eliminar(struct lista **entero, int dato)
{
struct lista *puntero, *anterior;
puntero = *entero;
anterior = NULL;
while((puntero != NULL) && (puntero->dato < dato))
{
anterior = puntero;
puntero = puntero->sig;
}
if(puntero->dato != dato)
cout<<"El numero no existe "<
else
{
if(anterior == NULL) //1er lista
*entero = (*entero)->sig;
else
anterior->sig = puntero->sig;
delete puntero;
}
}
void recorrer(struct lista **entero)
{
struct lista *puntero;
puntero = *entero;
while(puntero != NULL)
{
cout< dato<< " ";
puntero = puntero->sig;
}
}
int buscar(struct lista **entero, int dato)
{
struct lista *puntero;
puntero = *entero;
while((puntero != NULL) && (puntero->dato < dato)) puntero = puntero->sig;
if(puntero->dato == dato)
return 1;
else
return 0;
}
ANLISIS DE PROGRA28.CPP
Al analizar un poco el cdigo de progra28.cpp se tiene definida una
estructura llamada lista, que tiene como miembros a un puntero llamado *nuevo y
a *sig que es el enlace al siguiente elemento de la lista y es del tipo de la
estructura, al igual que los punteros *L y *P, utilizados para gestionar la lista. Se
define la variable i que es de tipo entero utilizada para el recorrido del ciclo for. El
cual est predefinido para que repita el proceso de insertar elementos 5 veces al
estar definido as: for(i=1;i<=6;i++).
El puntero P es utilizado para la reserva de memoria que se hace por medio
de Malloc(), lo que indica que P guardar los elementos que se inserten a la lista,
pero se requiere otro puntero que recorra la lista y esa labor la hace L.
Siguiendo algortmicamente las instrucciones del programa se tiene que se
almacena un nuevo dato que es el nmero 3 y que este se guarda en el apuntador
P tal como lo indica la instruccin p->nuevo=3.
Con la instruccin P->sig=L; se hace que p apunte al siguiente elemento de
lista posteriormente se reorganizan los enlaces en la instruccin L=P.
}
free(primero);
getch();
return 0;
}
El resultado despus de haber compilado y depurado el cdigo es el que se
visualiza en la figura
c = atoi(s);
}while(c<0 || c>5);
clrscr();
return c;
}
//Introducir nombres y direcciones
void intro(void)
{
struct direc *info;
for(;;)
{
info = (struct direc *)malloc(sizeof(struct direc));
if(!info)
{
cout<<<"no hay memoria";
return;
}
leecad("\nIntroduce el nombre: ", info->nombre, 30);
if(!info->nombre[0]) break; //parar el proceso
leecad("Introduce la ciudad: ", info->ciudad, 20);
leecad("Introduce el codigo: ", info->codigo, 10);
dl_insert(info, &ppio, &final);
}
clrscr();
}
/* Esta funcion lee una cadena de longitud maxima cont
y previene el desbordamiento de la cadena. tambien
visualiza un mensaje indicativo */
void leecad(char *indic, char *s, int cont)
{
char p[255];
do
{
printf(indic);
fgets(p, 254, stdin);
}while(strlen(p) > cont);
p[strlen(p)-1] = 0; //Eliminar el salto de linea
strcpy(s, p);
}
// crear una lista doblemente enlazada
void dl_insert(
struct direc *i, //nuevo elemento
struct direc **ppio, //primer elemento de la lista
struct direc **final //ultimo elemento de la lista
)
{
cout<<
}
// esta funcion imprime realmente los campos de cada direccion
void mostrar(struct direc *info)
{
cout<nombre<<"-";
cout<ciudad<<"-";
cout<codigo<<"-";
cout<<
}
//buscar un nombre en la lista
void buscar(void)
{
char nombre[40];
struct direc *info;
cout<<"Introduce el nombre a encontrar: ";
gets(nombre);
info = buscar(nombre);
if(!info)
cout<<"no encontrado";
else mostrar(info);
getch();
clrscr();
}
La salida en pantalla de progra30.cpp como implementacin de una lista
doblemente enlazada se puede visualizar en la figura se muestra a continuacin.
SOBRECARGA DE OPERADORES EN C+
La
sobrecarga de operadores, aunque puede ser una capacidad
extica, la mayora de personas las usa implcita y
regularmente se valen de los operadores sobrecargados.
Por ejemplo, el operador de suma (+) funciona de manera
+=
-=
*=
/=
%=
A=
&=
!=
<<
>>
>>=
<<=
==
!=
<=
>=
&&
||
++
-->*
->
[]
()
new
delete
new [ ]
delete []
}
string & string :: operator+= (string & s){
char *temps=ptr;
size+=s.size;
ptr=new char[size+1];
if(ptr==NULL){ cout<<"No hay memoria"; exit(0); }
strcpy(ptr, temps);
strcat(ptr, s.ptr);
delete [] temps;
return (*this);
//habilita llamadas en cascada
}char string :: operator[] (int num){
assert(num>=0 && num<size); //prueba si num est en el rango
return (ptr[num]);
}
//Devuelve subcadena que comienza en: inicio y de longitud: subsize
string string :: operator() (int inicio, int subsize){
//asegura que inicio este en el rango y que subsize sea >=0
assert(inicio>=0 && inicio<size && subsize >=0);
string *subptr= new string;
//string vaca
if(subptr==0){ cout<<"No hay memoria"; exit(0); }
//determina la longitud de la subcadena
if((subsize==0) || (inicio+ subsize> size))
subptr->size= size- inicio+ 1;
else
subptr->size= subsize+1;
//asigna memoria para la subcadena
delete subptr->ptr;
//borra el arreglo de caractres
subptr->ptr= new char[subsize];
if(subptr->ptr==NULL){ cout<<"No hay memoria"; exit(0); }
//copia la subcadena a la nueva string
strncpy(subptr->ptr, & ptr[inicio], subptr->size);
subptr->ptr[subptr->size]='\0'; //termina string
return (*subptr); //devuelve la nueva string
}
int string :: longitud (void){
return (size);
}
ostream & operator<< (ostream & salida, string & s){
salida<< s.ptr;
return (salida); //habilita el proceso en cascada
}
istream & operator>> (istream & entrada, string & s){
entrada>> s.ptr;
return (entrada); //habilita proceso en cascada
}
void main(void){
textcolor(BLACK);
textbackground(WHITE);
clrscr();
string s1("hola"), s2(" amigos"), s3;
//probando operadores de igualdad y relacionales
cout<<"s1: " <<s1 <<" , s2: " <<s2 <<" , s3: " <<s3;
cout<<endl<<endl<<"Resultados al comparar s1 y s2: "
<<endl<<"Resultado de s1==s2: " << (s1==s2 ? "verdadero" : "falso")
<<endl<<"Resultado de s1!=s2: " << (s1!=s2 ? "verdadero" : "falso")
<<endl<<"Resultado de s1> s2: " << (s1> s2 ? "verdadero" : "falso")
<<endl<<"Resultado de s1< s2: " << (s1< s2 ? "verdadero" : "falso")
<<endl<<"Resultado de s1>=s2: " << (s1>=s2 ? "verdadero" : "falso")
<<endl<<"Resultado de s1<=s2: " << (s1<=s2 ? "verdadero" : "falso");
//prueba operador sobrecargado (!)
cout<<endl<<endl<<"Probando !s3: ";
if(!s3){
cout<<"s3 esta vacio, asignando s1 a s3";
s3=s1;
cout<<"ns3: " << s3;
}
//probando operador sobrecargado de concatenacion
cout<<endl<<endl<<"Resultado de s1+=s2: "<<endl;
s1+=s2;
cout<<"s1: " <<s1;
//probando operador sobrecargado []
cout<<", s1[8]= " <<s1[8];
//prueba del operador sobrecargado ()
cout<<endl<<endl<<"Cadena resultante de s1(5,6): " <<s1(5,6) ;
//prueba el constructor de copiado
string *s4= new string(s1);
cout<<endl<<endl<<"Constructor copia para *s4: " <<*s4;
//prueba del operador de asignacion =
cout<<endl<<endl<<"Asignando s3 a *s4, *s4: ";
*s4=s3;
cout<< *s4
<<endl<<"Longitud de *s4: " <<s4->longitud();
getch();
}