clase martes 28 de enero 2014. notas de estructura de datos con lenguaje c arreglos (arrays) de...

Clase

Martes 28 de enero 2014

Notas de estructura de datos con lenguaje C

• ARREGLOS (ARRAYS) DE ESTRUCTURASe puede crear un arreglo de estructuras tal como se crea un arreglo de otros tipos. Los arreglos de estructuras son idóneos para almacenar un archivo completo de empleados, un archivo de inventario, o cualquier otro conjunto de datos que se adapte a un formato de estructura.Mientras que los arreglos proporcionan un medio práctico de almacenar diversos valores del mismo tipo.Los arreglos de estructuras le permiten almacenar juntos diversos valores de diferentes tipos, agrupados como estructuras.


• Por ejemplo la declaración de un arreglo de estructuras info_libro se puede hacer de un modo similar a cualquier arreglo, es decir,

struct info_libro libros [100];asigna un array de 100 elementos denominados libros.Para acceder a los miembros de cada uno de los elementos estructura se utiliza una notación de arreglo.


Para inicializar el primer elemento de libros, su código debe hacer referencia a los miembros de libros [0] de la forma siguiente:

strcpy (libros[0]. titulo, “Historia de México”);strcpy (libros[0]. autor, “Luis Moya”);strcpy (libros[0]. editorial, “McGraw-Hill”);libros[0].anyo=1999;


• También puede inicializarse un arreglo de estructuras en el punto de la declaración encerrando la lista de inicializadores entre llaves, {}. Por ejemplo:struct info_libros libros[3]={“Historia de México”, “Luis Moya”, “McGraw-Hill”, 1999, “Los Aztecas”, “Jorge García López”, “McGraw-Hill”, 1999, “El Mundo Maya”, “Rosendo Márquez”, “McGraw-Hill”, 1997};


El siguiente ejemplo se declara una estructura que representa a un número racional, un arreglo de números racionales es inicializado con valores al azar.

struct racional{

int N,int D;

};struct racional rs[4]={1, 2, 2, 3, -4, 7, 0, 1};

Tipos de datos abstractos (TDA)

Notas de estructura de datos con lenguaje C• La modularidad es la posibilidad de dividir una

aplicación en piezas más pequeñas llamadas módulos. • Abstracción de datos es la técnica de inventar nuevos

tipos de datos que sean más adecuados a una aplicación y por consiguiente, facilitar la escritura del programa. La técnica de abstracción de datos en una técnica potente de propósito general que cuando se utiliza adecuadamente, puede producir programas más cortos, más legibles y flexibles.

• Los objetos combinan en una sola unidad datos y funciones que operan sobre esos datos.


• Los lenguajes de programación soportan en sus compiladores tipos de datos. fundamentales o básicos (predefinidos), por ejemplo: int, char y float en C.

• La mayoría de los lenguajes de programación tienen características que permiten ampliar el lenguaje añadiendo sus propios tipos de datos.


• Un tipo de dato definido por el programador se denomina tipo abstracto de dato, TAD, (abstract data type ADT).

• El término abstracto se refiere al medio en que un programador abstrae algunos conceptos de programación creando un nuevo tipo de dato.


• La modularización de un programa utiliza la noción de tipo abstracto de dato (TAD) siempre que sea posible.

• Si el lenguaje de programación soporta los tipos que desea el programador y el conjunto de operaciones sobre cada tipo, se obtienen un nuevo tipo de dato denominado TAD.


Conceptos Clave

•Abstracción•Clase•Componentes•Encapsulación•Interfaz•Modularidad

•Objeto•Rol•Reutilización•Software•Tipos de datos y variables


EL PAPEL DE LA ABSTRACCIÓNEl problema de la complejidad de la programación de la informática.

• Se han desarrollado mecanismos utilizados por los programadores para controlar la complejidad como:

Se destaca la abstracción


• Como describe Wulft “los humanos hemos desarrollado una técnica excepcionalmente potente para tratar la complejidad: abstraernos de ella. Incapaces de dominar en su totalidad los objetos complejos, se ignoran los detalles no esenciales, tratando en su lugar con el modelo ideal del objeto y concentrándonos en el estudio de sus aspectos esenciales”.


La abstracción es la capacidad para encapsular y aislar la información, del diseño y ejecución.La progresión histórica de la abstracción en la programación comienza en los procedimientos y sigue en los módulos, tipos abstractos de datos y objetos.


La abstracción como un proceso natural mental

Las personas normalmente comprenden el mundo construyendo modelos mentales de partes del mismo, tratan de comprender cosas con las que pueden interactuar.


• El proceso de construcción de modelos es lo mismo que el diseño de software.

• El desarrollo de software es único, el diseño de software produce el modelo que puede ser ejecutado por una computadora.

• Los modelos mentales deben ser más sencillos que el sistema al cual imitan, o en caso contrario serán inútiles.


• Ejemplo:Consideremos un mapa como modelo de su territorio.

El mapa debe ser más sencillo que el territorio que modela. Que nos proporciona un mapa nos abstrae sólo aquellas características del territorio que deseamos modelar.


• Un mapa de carreteras modela cómo llegar de una posición a otra.

• Los modelos mentales abstraen esas características de un sistema requerido para su comprensión.mientras ignoran características irrelevantesEste proceso de abstracción es psicológicamente necesario y natural, la abstracción es crucial para comprender este complejo mundo.


De la historia: a principio de la computación, los programadores enviaban instrucciones binarias a una computadora manipulando directamente interrupciones en sus paneles frontales. Los nemotécnicos del lenguaje ensamblador eran abstracciones diseñadas para evitar que los programadores tuvieran que recordar las secuencias de bits que componen las instrucciones de un programa. El siguiente nivel de abstracción se consigue agrupando instrucciones primitivas para formar macroinstrucciones.


Ejemplo: un conjunto se puede definir por la abstracción como una colección no ordenada de elementos en el que no existen duplicados

De lo anterior se pueden especificar si sus elementos se almacenan en un arreglo, una lista enlazada o cualquier otra estructura de datos.


• Un conjunto de instrucciones realizadas por el programador se pueden invocar por una macroinstrucción.

• Una macroinstrucción instruye a la máquina para que realice algunas tareas.

• Tras los lenguajes de programación. ensambladores aparecieron los lenguajes de programación de alto nivel, que supusieron un nuevo nivel de abstracción.


Los lenguajes de programación de alto nivel permitieron a los programadores alejarse de las interioridades arquitectónicas específicas de una máquina dada.Cada instrucción en un lenguaje de alto nivel puede invocar varias instrucciones máquina, dependiendo de la computadora donde se compila el programa.Esta abstracción permitía a los programadores escribir software para propósito genérico, sin preocuparse sobre que máquina corría el programa.


• Secuencias de sentencias de lenguajes de alto nivel se pueden agrupar en procedimientos y se invocan por una sentencia.

• La programación estructurada alienta el uso de abstracciones de control tales como bucles o sentencias if-then que se han incorporado en lenguajes de alto nivel.

• sentencias de control permitieron a los programadores abstraer las condiciones comunes para cambiar la secuencia de ejecución.


• El proceso de abstracción fue evolucionando desde la aparición de los primeros lenguajes de programación.

• El método idóneo para controlar la complejidad de los problemas ha sido aumentar los niveles de abstracción.

• Abstraer un problema supone la capacidad de encapsular y aislar la información de diseño y ejecución.


• La progresión histórica de la abstracción va desde las estructuras de control, pasando por los procedimientos, los módulos, los tipos de datos y los objetos.

ProcedimientosLos procedimientos y funciones fueron unos de los primeros mecanismos de abstracción que se utilizaron ampliamente en lenguajes de programación.


• Los procedimientos permitían tareas que se ejecutaban rápidamente, o eran ejecutados sólo con ligeras variaciones, que se reunían en una entidad y se reutilizaban, en lugar se duplicar el código varias veces.

• El procedimiento proporciono la primera posibilidad de ocultación de información.


• Un programador podía escribir un procedimiento o conjunto de procedimientos, que serían utilizados por otros programadores y que no necesitaban conocer los detalles de implementación, sólo necesitaban el interfaz.

• Los procedimientos no resolvían todos los problemas. En particular, no eran un mecanismo efectivo para ocultar la información y para resolver un problema que se producía al trabajar múltiples programadores con nombres idénticos.


Módulos• Un módulo es una técnica que proporciona la

posibilidad de dividir sus datos y procedimientos en una parte privada –sólo accesible dentro del módulo- y una parte pública –accesible dentro del módulo- y una parte pública –accesible fuera del módulo.

Los tipos, de datos (variables) y procedimientos se pueden definir en cualquier parte.


• El criterio a seguir en la construcción de un módulo es que si no se necesita algún tipo de información, no se debe tener acceso a ella. Este criterio es la ocultación de información.

• Los módulos resuelven algunos problemas, pero no todos los problemas del desarrollo de software.

• Los módulos proporcionan un método efectivo de ocultación de la información, pero no permiten realizar instanciación, que es la capacidad de hacer múltiples copias de las zonas de datos.


Tipos abstractos de datos• Un tipo abstracto de datos (TAD) es un tipo de dato

definido por el programador que se puede manipular de un modo similar a los tipos de datos definidos por el sistema.

• Al igual que los tipos definidos por el sistema, un tipo de dato abstracto corresponde a un conjunto (puede ser de tamaño indefinido) de valores legales de datos y un número de operaciones primitivas que se pueden realizar sobre esos valores.


• Se pueden crear variables con valores que están en el rango de valores legales y pueden operar sobre esos valores utilizando las operaciones definidas.

• Los módulos se utilizan frecuentemente como una técnica de implementación para tipos abstractos de datos, y el tipo abstracto de datos es un concepto más teórico.


Para construir un tipo abstracto de datos se debe poder:1. Exponer una definición del tipo.2. Hacer disponible un conjunto de operaciones que se puedan

utilizar para manipular instancias de ese tipo.3. Proteger los datos asociados con el tipo de modo que sólo se

puede actuar sobre ellas con las rutinas proporcionadas.4. Hacer instancias múltiples del tipo.

Los módulos son mecanismos de ocultación de información y no cumplen básicamente más que los tres primeros apartados.


Objetos

Un objeto es sencillamente un tipo abstracto de datos al que se añaden importantes innovaciones en compartición de código y reutilización.

Los mecanismos básicos de orientación a objetos son: objetos, mensajes y métodos, clases e instancias y herencia.


Una idea fundamental es la comunicación de los objetos a través de paso de mensajes.Además de esta idea, se añaden los mecanismos de herencia y polimorfismo. La herencia permite diferentes tipos de datos para compartir el mismo código, permitiendo una reducción en el tamaño del código y un incremento en la funcionalidad.

El polimorfismo permite que un mismo mensaje pueda actuar sobre objetos diferentes y comportarse de modo distinto.


La persistencia se refiere a la permanencia de un objeto, esto es, la cantidad de tiempo para el cual se asigna espacio y permanece accesible en la memoria del computador.


CONCEPTOS CLAVES • Abstracción

• Encapsulación • Persistencia • Herencia

• Polimorfismo• Generecidad (generalidad)

ENTIDADES BÁSICAS • Objeto• Mensajes Métodos • Clases Instancias • Herencia Jerarquía • Polimorfismo


TIPOS DE DATOS

Todos los lenguajes de programación soportan algún tipo de datos.

En C soporta: base como enteros, reales y caracteres; así como tipos compuestos tales como arreglos (vectores y matrices) y estructuras (registros).


Un valor depende de su representación y de la interpretación de la representación, por lo que una definición informal de un tipo de dato es: Representación + Operaciones.

Un tipo de dato describe un conjunto de objetos con la misma representación.


Existen un número de operaciones asociadas con cada tipo.

Es posible realizar aritmética sobre tipos de datos enteros y reales, concatenar cadenas o recuperar o modificar el valor de un elemento.La mayoría de los lenguajes tratan las variables y constantes de un programa como instancias de un tipo de dato.


Un tipo de dato proporciona una descripción de sus instancias que indican al compilador cosas como cuánta memoria se debe asignar para una instancia, cómo interpretar los datos en memoria y qué operaciones son permisibles sobre esos datos.Ejemplo: cuando se escribe una declaración tal como float Pato en C ó C++, se está declarando una instancia denominada Pato del tipo de dato float.


El tipo de datos float indica al compilador que reserve, por ejemplo, 32 bits de memoria y que operaciones tales como “sumar” y “multiplicar” esta permitidas, mientras que operaciones tales como el “el resto” (módulo y “desplazamiento de bits” no lo están.


Los tipos de datos que se construyen en un compilador de este modo se conocen como tipos de datos fundamentales (predefinidos), y por ejemplo en C y C++ son entre otro: int, char, float y double.Nota: El programador no tienen que preocuparse de saber cómo el compilador del lenguaje implementa los tipos de datos predefinidos, simplemente usa los tipos de datos en el programa.


Cada lenguaje de programación incorpora una colección de tipos de datos fundamentales, que incluyen normalmente enteros, reales, carácter, etc. Los lenguajes de programación soportan también un número de constructores de tipos incorporados que permiten generar tipos más complejos.

Por ejemplo, C soporta registros (estructuras) y arreglos(arrays).


ABSTRACCIÓN EN LENGUAJES

En los lenguajes de programación se pueden implementar los modelos abstractos.

La abstracción se dividen en dos categorías:

– abstracción de datos (pertenecientes a los datos) – abstracción de control (perteneciente a las estructuras de

control).


Desde que se desarrollaron los lenguajes de alto nivel, ha sido posible utilizar las abstracciones más primitivas de ambas categorías (variables, tipos de datos, procedimientos, control de bucles, etc.).Ambas categorías de abstracciones han producido una gran cantidad de lenguajes de programación no siempre bien definidos.


Abstracciones de controlLos microprocesadores ofrecen directamente sólo dos mecanismos para controlar el flujo y ejecución de las instrucciones: secuencia y salto.Los primeros lenguajes de alto nivel introdujeron las estructuras de control: sentencias de bifurcación (if) y bucles (for, while, do-while, etc.).Las estructuras de control dan el orden de ejecución las instrucciones o grupos de instrucciones(unidades de programa).

Notas de estructura de datos con lenguaje CLas unidades de programa se utilizan como bloques básicos de la clásica descomposición “descendente”Los subprogramas constituyen una herramienta potente de abstracción porque definen cómo funcionan los subprogramasEl subprograma(es una caja negra que amplían el código a utilizar ) se llama, basta con conocer lo que hace opero NO cómo lo hace.Los subprogramas son los mecanismos más utilizados para reutilizar código, a través de colecciones de subprogramas en bibliotecas.


Las abstracciones y estructuras de control se clasifican en estructuras de control a nivel de sentencia y a nivel de unidades.

Las abstracciones de control a nivel de unidad se conocen como abstracción procedimental.

Notas de estructura de datos con lenguaje CAbstracción procedimental (por procedimientos)Para crear software modular y fiable.

La abstracción procedimental se basa en empleo: procedimientos y funciones sin preocuparse de cómo se implementan.Esto, sólo si conocemos qué hace el procedimiento, sí , conocemos la sintaxis y semántica del procedimiento o función. El único mecanismo en C para establecer abstracción procedimental es el subprograma (funciones).


La abstracción aparece en los subprogramas solo:

Con el nombre de los subprogramas (descripción abstracta que captura el significado global del subprograma) , al usar el nombre en lugar de escribir el código nos permite aplicar la acción en términos de su descripción de alto nivel en lugar de sus detalles de bajo nivel.


Los subprogramas en C proporcionan ocultación de la información.

Las variables locales y cualquier otra definición local se encapsulan en el subprograma, ocultándolos de forma que no se puedan utilizar fuera del subprograma. No se tiene que preocuparse sobre las definiciones locales; sin embargo, pueden utilizarse los componentes sin conocer sus detalles.


Los parámetros de los subprogramas, junto con la ocultación de la información, permiten crear subprogramas que constituyen entidades de software propias.

Los detalles locales de la implementación pueden estar ocultos mientras que los parámetros se pueden utilizar para establecer el interfaz público.


Otros mecanismos de abstracción:Existen otros mecanismos para la abstracción de control como: manejo de excepciones, corrutinas, unidades concurrentes, plantillas (templates). Estas construcciones son soportadas por los lenguajes de programación basados y orientados a objetos, tales como Modula-2, Ada, C++, Smalltalk, Java o C#.


SIMULA-67 fue el primer lenguaje que mezcló datos y procedimientos mediante la construcción de clases, que se convirtió en la base del desarrollo de programación orientada a objetos.

• La abstracción de datos es la técnica de programación que permite inventar o definir nuevos tipos de datos (tipos de datos definidos por el programador) adecuados a la aplicación . La abstracción de datos es una técnica muy potente que permite diseñar programas más cortos, legibles y flexibles.


Nota: La esencia de la abstracción es similar a la utilización de un tipo de dato, cuyo uso se realiza sin tener en cuenta cómo está representado o implementado.Los tipos de datos son abstracciones y el proceso de construir nuevos tipos se llama abstracción se datos.

Los nuevos tipos de datos definidos se les llaman tipos de datos.


No todos lenguajes no soportan totalmente una metodología orientada a objetos.

La abstracción de datos útil para este propósito, no sólo clasifica objetos de acuerdo a su estructura de representación; sino que se clasifican de acuerdo al comportamiento esperado.

Tal comportamiento es expresable en términos de operaciones que son significativas sobre esos datos, y las operaciones son el único medio para crear, modificar y acceder a los objetos.

Notas de estructura de datos con lenguaje CGhezzi define que un tipo de dato se denomina tipo abstracto de dato (TAD) si:

• Existe una construcción del lenguaje que le permite asociar la representación de los datos con las operaciones que lo manipulan;

• La representación del nuevo tipo de dato está oculta de las unidades de programa que lo utilizan [Ghezzi 87].

Notas de estructura de datos con lenguaje C• Los TDA proporcionan un mecanismo adicional

mediante el cual se realiza una separación clara entre la interfaz y la implementación del tipo de dato. La implementación de un tipo abstracto de dato consta de:1. La representación: elección de las estructuras de datos.2. Las operaciones: elección de los algoritmos.

La interfaz del tipo abstracto de dato se asocia con las operaciones y datos visibles al exterior del TAD.

Notas de estructura de datos con lenguaje CNOTA: TAD

Algunos lenguajes de programación tienen características que nos permite ampliar el lenguaje añadiendo sus propios tipos de datos.

Un tipo definido por el programador se denomina tipo abstracto de datos (TAD).

Se implementa considerando los valores que se almacenan en las variables y las operaciones disponibles para manejar esas variables.


Ejemplo: en C el tipo Perro, que representa a las coordenadas x e y de un sistema de coordenadas rectangulares, no existe;

En el programa se puede definir el tipo abstracto de datos Perro que represente las coordenadas rectangulares, y las operaciones que se pueden realizar (distancia, módulo…).


Es esencia un tipo abstracto de datos es un tipo de datos que consta de datos (estructura de datos propias) y operaciones que se pueden realizar sobre esos datos.

Un TAD se compone de estructuras de datos y procedimientos o funciones que manipulan esas estructuras de datos.


Un tipo abstracto de datos puede definirse mediante la ecuación:

TAD = Representación (datos) + Operaciones (funciones y procedimientos)

De manera general, un tipo abstracto de datos se compone del interfaz y de la implementación


Interfaz pública Interfaz pública

Método 1 Método 3

Método 2 Método 4


Implementación privada

Representación:

Estructura de datos (variables instancia)

Implementación de métodos:

Código del método 1Código del método 2Código del método 3Código del método 4. . .


Ventajas del uso de los TDA´s• Un tipo abstracto de datos es un modelo (estructura)

con un número de operaciones que afectan a este modelo. Los tipos abstracto de datos proporcionan numerosos beneficios al programador, que se pueden resumir como:

1. Permite una mejor conceptualización y modelización del mundo real. Mejora la representación y la comprensibilidad. Clarifica los objetos basados en estructuras y comportamientos comunes.


2. Mejora la robustez del sistema.Los tipos abstractos de datos permiten la comprobación de tipos para evitar errores de tipo en tiempo de ejecución.

3. Mejora el rendimiento . El conocimiento de los objetos permite la optimización de tiempo de compilación en los programas.

4. Separa la implementación de la especificación. Permite la modificación y mejora de la implementación sin afectar al interfaz público del tipo de dato.


5.Permite la extensibilidad del sistema. Los componentes de software reutilizables son más fáciles de crear y mantener.

6.Reúne mejor la semántica del tipo. Los tipos abstractos de datos agrupan o localizan las operaciones y la representación de atributos.


Un programa que maneja un TAD lo hace teniendo en cuenta las operaciones o funcionalidades que tiene, sin interesarse por la representación física de los datosEs decir, los usuarios de un TAD se comunican con este a partir del interfaz que ofrece el TAD mediante funciones de acceso. Podría cambiarse la implementación de tipo de datos sin afectar el programa que usa el TAD ya que para el programa está oculta la implementación.

Notas de estructura de datos con lenguaje CSintaxis de las operaciones:(nota: se lista las operaciones indicando los tipos de los argumentos y el tipo del resultado)

Operación (Tipo de argumento, …) -> Tipo resultadoContinúa con la semántica de las operaciones.Esta se construye dando unos valores particulares a los argumentos de las operaciones, a partir de los cuales se obtiene una expresión resultado. Este puede tener referencias a tipos ya definidos, valores de tipo lógico o referencia a otras operaciones del propio TAD.


SemánticaOperación (valores particulares argumentos)

=> expresión resultadoAl hacer una especificación formal siempre hay operaciones definidas por sí mismas, se consideran constructores del TAD.Se puede decir que mediante estos constructores se generan todos los posibles valores del TAD.


Normalmente, se elige como constructor la operación que inicializa.

ejemplo, (Conjunto vacío en el TAD Conjunto) y la operación que añade un dato o elemento (esta operación es común a la mayoría de los tipos abstractos de datos). Se acostumbra a marcar con un asterisco a las operaciones que son constructores.


Por ejemplo para la especificación formal del TAD Conjunto, para formar la expresión resultado se hace uso, si es necesario, de la sentencia alternativa si-entonces-sino.

TAD Conjunto (colección de elementos sin duplicidades, pueden estar en cualquier orden, se usa para representar los conjuntos matemáticos con sus operaciones).

Notas de estructura de datos con lenguaje CSintaxis* Conjuntovacio -> Conjunto* Añadir (Conjunto, Elemento) -> ConjuntoRetirar (Conjunto, Elemento) -> ConjuntoPertenece (Conjunto, Elemento) -> ConjuntoEspacio (Conjunto) -> BooleanCardinal (Conjunto) -> EnteroUnión (Conjunto, Conjunto) -> Conjunto


Semántica e1, e2 Elemento y C,D Conjunto

Añadir (Añadir (C, e1), e1) =>Añadir (C, e1)Añadir (Añadir (C, e1), e2) =>Añadir (Añadir (C, e2), e1)Retirar (Conjuntovacio, e1) =>ConjuntovacioRetirar (Añadir (C, e1), e2) =>si e1 = e2 entoncesRetirar (c, e2)

sino Añadir (Retirar (C, e2), e1)Pertenece (Conjuntovacio, e1) =>falsoPertenece (Añadir (C, e2), e1) =>si e1 = e2 entonces cierto

sino Pertenece (C, e1)

Notas de estructura de datos con lenguaje CEspacio (Conjuntovacio) =>ciertoEspacio (Añadir (C, e1)) => falsoCardinal (Conjuntovacio) => CeroCardinal (Añadir (C, e1)) => si Pertenece (C, e1) entonces

Cardinal (C)Sino 1 + Cardinal (C)

Unión (Conjuntovacio, Conjunto vacio) => ConjuntovacioUnión (Conjuntovacio, Añadir (C, e1)) => Añadir (C, e1)Unión (añadir (C, e1), D) => Añadir (Union (C, D), e1)


La implementación del tipo abstracto de datos debe incluir dos partes diferenciadas:

• Representación de los datos.• Implementación de las operaciones descritas

en la especificación.


Los TDA´s en C:Las características del lenguaje que van a permitir implementar un TAD son, principalmente, las estructuras o registros para representación de los datos, y de las funciones para representar las operaciones especificadas.Además en un archivo de inclusión o de cabecera se guarda la representación de los datos y el interfaz, es decir, los prototipos de las funciones que implementan las operaciones del tipo abstracto.

Notas de estructura de datos con lenguaje CUna estructura es una agrupación de campos o variables de cualquier tipo predefinido.Permite que un grupo de variables que tienen una cierta relación lógica sean tratadas como un todo.

Como ejemplo tenemos: Un punto en el espacio tridimensional se

caracteriza por tres variables que representan a las respectivas coordenadas.

Notas de estructura de datos con lenguaje Cstruct punto3D{

float x;float y;float z;

};La sentencia typedef permite dar un nombre a un tipo de dato ya definido, de tal forma que se puede referir al tipo de dato con el nuevo nombre:

Typedef tipo_predefinido nuevo_nombre;Al declarar estructuras, la sentencia typedef se utiliza conjuntamente con la declaración del tipo estructura

Notas de estructura de datos con lenguaje CPara la estructura que representa coordenadas tridimensionales:typedef struct{

float x;float y;float z;float 3D;

};

El nuevo tipo punto 3DNos permitirá definir variables o declarar el tipo de una función.

punto 3D p1, p2;punto3D desplazamiento (Punto3D, float x);


Recuerde que la sentencia typedef identifica a un tipo de dato con un nuevo nombre con el fin de que sea más legible el código fuente.

Notas de estructura de datos con lenguaje CLos archivos de inclusión o de cabecera se utilizan para agrupar en ellos variables externas, declaraciones de datos comunes y prototipos de funciones.

Estos archivos de cabecera se incluyen en los archivos que contienen la codificación de las funciones, archivos fuente, y también en los archivos de código que hagan referencia a algún elemento del archivo de inclusión, con la directiva del preprocesador:

#include


Al implementar un TAD en C se agrupa, en cierto modo se encierra, en estos archivos la representación de los datos y el interfaz del TAD, a su vez representado por los prototipos de las funciones.

De esta forma en los archivos de código fuente que utilicen el TAD hay que escribir la directiva.

#include " tipodedato.h "

Notas de estructura de datos con lenguaje CEjemplo de uso: implementación del tipo Conjunto definido en el ejemplos no se establece que el conjunto pueda tener un máximo de elementos. Esto exige el uso de asignación dinámica de memoria.

En el archivo de cabecera, conjunto.h, se realiza la declaración de la estructura que va a representar a los datos.

El tipo de los datos puede ser cualquiera, entonces es necesario que

TipoDato esté especificado antes de incluir conjunto.h.

La constante M, que arbitrariamente toma el valor de 10, es un número de “huecos” o posiciones de memoria, que se reservan cada vez que hay que ampliar el tamaño de la estructura.

Notas de estructura de datos con lenguaje CArchivo conjunto.h#define M 10{

TipoDato* cto;int cardinal;int capacidad;

} Conjunto;

void conjuntoVacio (Conjunto* c);int esVacio (Conjunto c);void anadir(Conjunto* c, TipoDato elemento);void retirar(Conjunto* c, TipoDato elemento);void pertenece(Conjunto* c, TipoDato elemento);int cardinal(Conjunto c);Conjunto unión (Conjunto c1, Conjunto c2);

Este archivo de cabecera conjunto.h, se tiene que incluir en todos los archivos con código que vaya a utilizar el tipo Conjunto.

Es importante recordar que antes de escribir la sentencia include hay que asociar un tipo predefinido a TipoDato.

Por ejemplo, si los elementos del conjunto son las coordenadas de un punto en el plano:

typedef struct{ float x;

float y;} Punto;

typedef Punto TipoDato;#include "conjunto.h”

Las funciones cuyos prototipos han sido ya escritos, se codifican y se guardan en el archivo conjnto.c. La compilación de conjunto.c da lugar al archivo con el código objeto que se ensamblará con el código objeto de otros archivos fuente que hacen uso del TAD Conjunto.

Archivo conjunto.cTypedef Tipo TipoDato;#include “conjunto.h”

/* iguales() devuelve 1(cierto) si todos los campos lo son. La implementación depende del tipo concreto de los datos del

conjunto.*/ Int iguales (TipoDato e1, TipoDato e2){

return (e1.v1 ==)&&(e1.v2 == e2.v2)…;}

Void conjuntoVacio (Conjunto* c){

c -> cardinal = 0;c -> capacidad =M;

c -> cto = (Tipodato*)malloc (M*sizeof(TipoDato));} int esVacio (Conjunto c){

return (c.cardinal==0);}

void anadir (Conjunto*c, TipoDato elemento){if (!pertenece (*c, elemento))

{ /* verifica si hay posiciones libres, en caso contrario amplia el conjunto*/if (c-> cardinal ==c -> capacidad){

Conjunto nuevo;int k, capacidad;capacidad = (c-> capacidad + M)*sizeof (TipoDato)nuevo.cto = (TipoDato*)malloc(capacidad);for (k=0; k<c -> capacidad; k++)

nuevo.cto[k]= c -> cto [k];free (c-> cto);

c-> cto = nuevo.cto; } c -> cto[c -> cardinal ++] = elemento; }}

void mostrar (Conjunto c){

int k;puts (“\n Mostrar conjunto ”);for (k=0; k<c.carninal: ){

printf(“%d/%d ”, c.cto[k].n, c.cto[k].d);k++;if (k%10 ==0) puts (“ ”);

}}

La función iguales( ) adaptada para verificar si dos números racionales son iguales:

int iguales (TipoDato e1, TipoDato e2){return (e1.n == e2.n) && (e1.d == e2.d);}

Listas Enlazadas


Estructuras de datos dinámicas.

Contrariamente a las estructuras de datos estáticas (arreglos-listas, vectores y tablas- y estructuras) en las que su tamaño en memoria se establece durante la ejecución del programa, las estructuras de datos dinámicas crecen y se contraen a medida que se ejecuta el programa.


Estructuras lineales de elementos homogéneas (listas, tablas, vectores) y se utilizaban arreglos para implementar estas estructuras (de tamaño fijo y predefinido el espacio a ocupar en memoria).

De modo que cuando se desea añadir un nuevo elemento que rebase el tamaño prefijado del arreglo, no es posible realizar la operación sin que se produzca un error un tiempo de ejecución.

Se debe a que los arreglos hacen un uso ineficiente de la memoria.


Gracias a la asignación dinámica de variables, se pueden implementar listas de modo que la memoria física utilizada se corresponda con el número de elementos de la tabla. Para ello se recurre a los apuntadores (punteros) que hacen un uso más eficiente de memoria

Una lista enlazada es una colección o secuencia de elementos dispuestos uno detrás de otro, en la que cada elemento se conecta al siguiente elemento por un <<enlace>> o <<apuntador>>.


La idea básica consiste en construir una lista cuyos elementos llamados nodos se componen de dos partes o campos: la primera parte o campo contiene la información y es, por consiguiente, un valor de un tipo genérico (denominados Dato, Tipo Elemento, Info, etc) y la segunda parte o campo es un puntero (denominado enlace) que apunta al siguiente elemento de la lista.


Consiste en construir una lista cuyos elementos llamados nodos se componen de dos partes o campos:

La primera parte o campo contiene la información y es, por consiguiente, un valor de un tipo genérico (denominados Dato, Tipo Elemento, Info, etc).

La segunda parte o campo es un puntero (denominado enlace) que apunta al siguiente elemento de la lista.


Lista enlazada (representación simple)

• La representación gráfica más extendida es aquella que utiliza una caja (un rectángulo) con dos secciones en su interior.


En la primera sección se escribe el elemento o valor del dato y en la segunda sección, el enlace o apuntador mediante una flecha que sale de la caja y apunta al nodo siguiente.

Lista enlazada (representación gráfica típica)


Nota: una lista enlazada consta de un número de elementos y cada elemento tiene dos componentes (campos), un puntero al siguiente elemento de la lista y un valor, que puede ser de cualquier tipo.

Los enlaces representan por flechas para facilitar la comprensión de la conexión entre dos nodos; ello indica que el enlace tiene la dirección en memoria del siguiente nodo.

Notas de estructura de datos con lenguaje C• Los enlaces también sitúan los nodos en una

secuencia.

Los nodos forman una secuencia desde el primer elemento (e1) al último elemento (en).

El primer nodo se enlaza al segundo nodo, el segundo nodo se enlaza al tercer y así sucesivamente hasta llegar al último nodo. El nodo último ha de ser representado de forma diferente para significar que este nodo no se enlaza a ningún otro.


Diferentes representaciones gráficas del último nodo:

Notas de estructura de datos con lenguaje CLas listas se pueden dividir en cuatro categorías:

Listas simplemente enlazadas. Cada nodo (elemento) contiene un único enlace que conecta ese nodo al nodo siguiente o nodo sucesor. La lista es eficiente en recorridos directos (<<adelante>>).

Listas doblemente enlazadas. Cada nodo contiene dos enlaces, uno a su nodo predecesor y el otro a su nodo sucesor. La lista es eficiente tanto en recorrido directos(<<adelante>>) como en recorrido inverso (<<atrás>>).

Notas de estructura de datos con lenguaje CLista circular simplemente enlazada.

Una lista enlazada simplemente es la que el último elemento (cola) se enlaza al primer elemento (cabeza) de tal modo que la lista puede ser recorrida de modo circular (<<en anillo>>).

Lista circular doblemente enlazada. Una lista doblemente enlazada es la que el último elemento se enlaza al primer elemento y viceversa. Esta lista se puede recorrer de modo circular (en anillo) tanto en dirección (<<adelante>>) como viceversa (<<atrás>>).

Notas de estructura de datos con lenguaje CPara la construcción de las listas se puede elegir una implementación basada en arreglos o basada en apuntadores.

Como ya se ha comentado estas implementaciones difieren en el modo en que asigna la memoria para los datos de los elementos, cómo se enlazan juntos los elementos y cómo se accede a dichos elementos. De forma más específica, las implementaciones pueden hacerse con:

Asignación fija o estática, de memoria mediante arreglos. Asignación dinámica de memoria mediante apuntadores.

Es importante comentar que la asignación fija de memoria mediante arreglos es más ineficiente.Por lo que solo desarrollaremos -la asignación de memoria mediante apuntadores.

Notas de estructura de datos con lenguaje CConceptos de ListasUna lista enlazada consta de un conjunto de nodos. Un nodo consta de un campo dato y un puntero que

apunta al <<siguiente>> elemento de la lista.

• El primer nodo, frente, es el nodo apuntador por cabeza. La lista encadenada nodos juntos desde el frente al final (cola) de la lista. El final se identifica como el nodo cuyo campo apuntador tiene el valor NULL = 0.


La lista se recorre desde el primero al último nodo; en cualquier punto del recorrido la posición actual se referencia por el apuntador Ptr_actual.

En el caso que la lista está vacía el apuntador cabeza es nulo.

Notas de estructura de datos con lenguaje C OPERACIONES EN LISTAS ENLAZADAS

Las lista enlazada requiere controles para la gestión de los elementos contenidos en ellas. Estos controles se expresan en forma de operaciones que tendrán las siguientes funciones:

Declaración de los tipos nodo y apuntador a nodo. Inicialización o creación. Insertar elementos en una lista. Buscar elementos de una lista (comprobar la existencia de

elementos en una lista). Recorrer una lista enlazada (visitar cada nodo de la lista). Comprobar si la lista está vacía.


Como se declara de un nodo:

Una lista enlazada se compone de una serie de nodos enlazados mediante apuntadores.

Cada nodo es una combinación de dos partes: Un tipo de dato (entero, real, doble, carácter o tipo predefinido) Un enlace (apuntador) al siguiente nodo.

En C se puede declarar un nuevo tipo de dato para un nodo mediante las palabras reservadas struct que contiene las dos partes.


struct Nodo{int dato;

struct Nodo* enlace;};

La declaración utiliza el tipo struct que permite agrupar campos de diferentes tipos, el campo dato y el campo enlace.

typedef struct Nodo{

Int dato;struct Nodo *enlace}NODO;

Con typedef se puede declarar a la vez un nuevo identificador de struct Nodo, en este caso se ha elegido NODO.


Dado que los tipos de datos que se pueden incluir en una listas pueden ser de cualquier tipo (enteros, reales, caracteres o incluso cadenas).Con el objeto de que el tipo de dato de cada nodo se pueda cambiar con facilidad.

Se utiliza la sentencia typedef para declarar el nombre de Elemento como un sinónimo del tipo de dato de cada campo.

Notas de estructura de datos con lenguaje CEl tipo Elemento se utiliza entonces dentro de la estructura nodotypedef double Elemento;

struct nodo{

Elemento dato;struct nodo *enlace;}; Si se necesita cambiar el tipo de elemento en los nodos sólo

tendrá que cambiar la sentencia de declaración de tipos que afecta a Elemento. Siempre que una función necesite referirse al tipo del dato del nodo, puede utilizar el nombre Elemento.

Ejemplo se declara un tipo denominado PUNTO que representa un punto en el plano con su coordenada x y y. Se declara el tipo NODO con el campo dato del tipo PUNTO. Se define un apuntador a NODO.

#include <stdlib.h>typedef struct punto{float x, y;} PUNTO;typedef struct Nodo{PUNTO dato;Struct Nodo* enlace;}NODO;NODO* cabecera;cabecera = NULL;


Apuntador al nodo inicial y al nodo final.

Los programas no declaran variables de nodos. Cuando se construye y emplea una lista enlazada, a la lista se accede

a través de uno o más apuntadores a los nodos. El acceso más común a una lista enlazada es a través del primer nodo

de la lista que se llama nodo inicial (cabeza o cabecera) de la lista. Un apuntador al primer nodo se llama, apuntador al inicial o

apuntador cabecera. Nota: algunas veces se tiene un apuntador al último nodo de una lista

enlazada.


El último nodo es la final (cola ) de la lista, y un apuntador al último nodo es el nodo final ( apuntador cola).

También se pueden tener apuntadores a otros nodos de la lista enlazada.

Declaraciones de tipo en lista enlazada

Declaración del nodo:

typedef double elemento;struct nodo{

elemento dato;struct nodo *enlace;

};

Definición de apuntadores:

struct nodo *ptr_cabeza; struct nodo *ptr_cola;

Notas de estructura de datos con lenguaje CCada apuntador de acceso a la lista debe estar declarado como una variable apuntador.

Si se requiere una lista enlazada con un apuntador inicial (cabecera) y final (cola) es necesario declararlas variables apuntador

Por ejemplo:

struct nodo *ptr_cabeza;struct nodo *ptr_cola;


Nota: El tipo struct a veces se simplifica utilizando la declaración typedef.Por ejemplo:

typedef struct nodo NODO;typedef struct nodo* ptrnodo;ptrnodo ptr_cabeza;ptrnodo ptr_cola;


Notas Importantes

La construcción y manejo de una lista enlazada requiere el acceso a los nodos de la lista a través de uno o más apuntadores a nodos. Normalmente, un programa incluye un apuntador al primer nodo (cabeza) y un apuntador al último nodo (cola).El último nodo de la lista contiene un valor de 0, esto es, un apuntador nulo (NULL) que señala el final de la lista.


La palabra NULL representa el apuntador nulo, que es una constante especial de C

El apuntador nulo se utiliza en dos situaciones:• Usar el apuntador en el campo enlace o siguiente nodo final de una

lista enlazada.• Cuando una lista enlazada no tiene ningún nodo, se utiliza el

apuntador NULL como apuntador de inicial (cabeza) y de final (cola). • A lista se denomina lista vacía.


El apuntador nulo se puede escribir como NULL, que es una constante de la biblioteca estándar stdlib.h.El apuntador nulo se puede asignar a una variable apuntador con una sentencia de asignación ordinaria.


Nota Importante

El apuntador de inicial (cabeza) y de final (cola) es una lista enlazada puede ser NULL, lo que indicará que la lista es vacía (no tiene nodos).Éste suele ser un método usual para construir una lista.Cualquier función que se escriba para manipular listas debe manejar un apuntador de inicial (cabeza) y un puntero de final(cola) nulos.

Notas de estructura de datos con lenguaje CEl operador -> de selección de un miembro:

Si pato es un apuntador a una estructura y mono es un miembro de la estructura, entonces pato -> mono accede al miembro mono de la estructura apuntada por pato.

”->” se considera como un operador simple. Se denomina operador de selección de miembro o también

operador de selección de componente. operador pato ->mono recuerda a una flecha que apunta del

apuntador pato al objeto que contiene al miembro mono.


Suponiendo que un programa ha de construir una lista enlazada y crear un apuntador de inicial (cabecera) ptr_cabeza a un nodo Nodo, el operador * de dirección aplicado a una variable apuntador representa el contenido del nodo apuntado por ptr_cabeza. Es decir, *ptr_cabeza es un tipo de dato Nodo.

Al igual que con cualquier objeto se puede acceder a los dos miembros de *ptr_cabeza.

Sentencia describe datos del nodo inicial (cabecera)

printf (“%f”, (*ptr_cabeza).dato);(*ptr_cabeza) miembro dato del nodo apuntado por

ptr_cabeza.


Nota ImportanteLos paréntesis son necesarios en la primera parte de la

expresión (*ptr_cabeza) ya que los operadores unitarios que aparecen a la derecha tienen prioridad más alta que los operadores unitarios que aparecen en el lado izquierdo (el asterisco de dirección).

Sin los paréntesis, el significado de ptr_cabeza producirá un error de sintaxis, al intentar evaluar ptr_cabeza.dato antes de la dirección o referencia.


A recordar

alumno -> matricula significa lo mismo que (*alumno).matricula

Utilizando el operador de selección -> se puede imprimir los datos del primer nodo de la lista.

printf(“%lf”, ptr_cabeza ->dato);


Error Frecuente

Los errores típicos en el tratamiento de apuntadores es escribir la expresión *p o bien p-> cuando el valor del apuntador p es el apuntador nulo, ya que como se sabe el apuntador nulo no apunta a nada


Para crear una lista Paso 1. Declarar el tipo de dato y el apuntador de inicial (cabeza)

o primero.Paso2. Asignar memoria para un elemento del tipo definido

anteriormente utilizando alguna de las funciones se asignación de memoria (malloc ( ), calloc ( ), realloc( )) y un cast para la conversión de void* al tipo apuntador a nodo; la dirección del nuevo elemento es ptr_nuevo.

Paso 3. Crear iterativamente el primer elemento (cabeza) y los elementos sucesivos de una lista enlazada simplemente.

Paso 4. Repetir hasta que no haya más entrada para el elemento.

Notas de estructura de datos con lenguaje CEjemplo: desarrollar una lista enlazada de elementos que almacenen datos de tipo entero.Un elemento de la lista se puede definir con la ayuda de la estructura siguiente:

struct Elemento{

Int dato;Struct Elemento * siguiente;};typedef struct Elemento Nodo;

En la estructura Elemento hay dos miembros, dato, que contiene el valor del elemento de la lista y siguiente que es un apuntador al siguiente nodo. También se declara un nuevo tipo: Nodo que es sinónimo de struct Elemento.

Notas de estructura de datos con lenguaje C El siguiente paso para construir la lista es declarar la variable

Primero que apuntará al primer elemento de la lista:

Nodo *Primero = NULLEl puntero Primero (también se puede llamar Cabeza) se ha inicializado a un valor nulo, lo que implica que la lista está vacía (no tiene elementos).

Se crea un elemento de la lista, para ello hay que reservar memoria, tanta como tamaño tiene cada nodo, y asignar la dirección de la memoria reservada al apuntador Primero:

Primero = (Nodo*) malloc (sizeof(Nodo));El operador sizeof se obtiene el tamaño de cada nodo de la lista, la función malloc( ) devuelve un apuntador genérico (void*), por lo que se convierte a Nodo*.


Se puede asignar un valor al campo dato:

Primero -> dato = 11;Primero -> siguiente =NULL;

Apuntador Primero apunta al nuevo elemento, se inicializa a 11. El campo siguiente del nuevo elemento toma el valor nulo, por

no haber un nodo siguiente. La operación de crear un nodo se puede hacer en una función a la que se pasas el valor del campo dato y del campo siguiente.

Notas de estructura de datos con lenguaje CLa función devuelve un apuntador al nodo creado:Nodo* Crearnodo (int x, Nodo* enlace){

Nodo *p;p = (Nodo*)malloc(sizeof (Nodo));p->dato = x;p-> siguiente = enlace;return p;

}La función CrearNodo () para crear el primer nodo de la lista:

Primero = Crearnodo (11, NULL);

Notas de estructura de datos con lenguaje CPara añadir un nuevo elemento con un valor 6, y agregarlo en el

primer lugar de la lista:

Primero = Crearnodo (6, Primero);

Para una lista con los datos 4, 6, 11Primero = Crearnodo (4, Primero);


Insertar un elemento en una lista

Para añadir o insertar un elemento en una lista enlazada el algoritmo varía dependiendo de la posición en que se insertar el elemento.Inserción puede ser:

• Al principio de la lista (cabeza o elemento primero) de la lista.• Al final de la lista (elemento último).• Antes de un elemento especificado.• Después de un elemento especificado.


Insertar un nuevo elemento en la cabeza de una listaEs más fácil y más eficiente insertar un elemento nuevo al principio de la lista.

El proceso de inserción:• Asignar un nuevo nodo apuntado por el nuevo que es una variable

apuntador local que apunta al nuevo nodo que se va a insertar en la lista.

• Situar el nuevo elemento en el campo dato del nuevo nodo.• Hacer que el campo enlace siguiente del nuevo nodo apunte a

primer nodo (cabeza) de la lista original.• Hacer que primer nodo (apuntador cabeza) apunte al nuevo nodo

que se ha creado.

Notas de estructura de datos con lenguaje CEjemplo: se tiene una lista contiene tres elementos, 10, 25 y 40 se

requiere insertar un nuevo elemento 4, al principio de la lista.

Paso 1 y paso 2

Notas de estructura de datos con lenguaje Ctypedef int Item;typedef struct tipo_nodo{

Item dato;struct tipo_nodo* siguiente;} Nodo; /*declaración del tipo Nodo*/Nodo* nuevo;nuevo = (Nodo*)malloc (sizeof (Nodo)); /*se asigna un nuevo

nodo*/nuevo-> dato = entrada;


Paso 3El campo enlace (siguiente) del nuevo nodo apunta a la cabeza actual de la lista:

nuevo -> siguiente = cabeza;

Paso 4Se cambia el apuntador de cabeza para apuntar al nuevo nodo creado; es decir, el puntero de cabeza apunta al mismo sitio que apunte nuevo:

En este momento, la función de insertar un elemento termina su ejecución.

La variable local nuevo desaparece y sólo permanece el apuntador de cabeza que apunta a la nueva lista enlazada.


La variable local nuevo desaparece y sólo permanece el apuntador de cabeza que apunta a la nueva lista enlazada:

El código de la función InsertarCabezaLista:

Void InsertarCabezaLista (Nodo** cabeza, ítem entrada);{

Nodo *nuevo;nuevo = (Nodo*)malloc (sizeof (Nodo)); /*asigna nuevo nodo*/

nuevo -> dato = entrada; /*pone elemento en nuevo*/

nuevo -> siguiente = *cabeza; /* enlaza nuevo nodo al frente de la lista*/

*cabeza = nuevo /* mueve puntero cabeza y apunta al nuevo nodo*/

}


La función InsertarCabezaLista actúa también correctamente si se trata el caso de añadir un primer nodo o elemento a una lista vacía, como ya se ha comentado cabeza apunta a NULL y termina apuntando al nuevo nodo de la lista enlazada.

Referencias Bibliográficas

• 1. Aho A. V., Ullman J. D., Hopcroft J. E., "Estructuras de datos y algoritmos", Pearson, 2000.

• 2. Sedgewick R., "Algorithms in C Parts 1-4: Fundamentals, Data structures, Sorting, Searching", Addison Wesley, 3ra ed., 2001.

• 3. Sedgewick R., "Algorithms in C Part 5: Graph algorithms", Addison Wesley,

• 3ra ed., 2001.• 4. Sedgewick R., "Algoritmos en C++", Pearson, 1995.

clase martes 28 de enero 2014. notas de estructura de datos con lenguaje c arreglos (arrays) de...

Documents