Control 5

Jorge Olguín Leiva

Estructura de Datos

Instituto IACC

16/12/2017
 Desarrollo

Antes debo aclarar que la materia de esta semana dio un giro de 90 grados en dificultad.

Afortunadamente encontré un ejercicio casi igual al solicitado pero no era cosa de copiar y pegar

o copiar las instrucciones ahí mostradas, tuve que analizar cada línea, en especial por el uso de

clases, ya que cuando en un ramo anterior vimos algo de PHP, no se vio este tema por lo que el

tiempo empleado a tratar de aprender clases con sus métodos y atributos fue mucho más del

tempo máximo que había empleado en algún otro ramo. Me fue muy difícil poder finalizar este

control (el material entregado no me fue suficiente), pero comprendí, por lo menos a medias, el

funcionamiento de las famosas clases y objetos. El programa original estaba con el ingreso de los

datos ordenados en forma manual, se le agrego una sentencia que selecciona los pares e impares

y se creó un array para alimentar la lista inicial.

Primero se debe crear la clase con las variables que contiene el elemento a almacenar en dicho

nodo y otra variable que contiene el puntero con la posición del siguiente nodo.

Función para crear el nodo.

class Nodo {
public $dato; (atributo)
public $proximo; (atributo)
public finction _construt ($elemento){ (método)
$this -> dato = $elemento;
$this -> próximo = null;
}
}
Con eso ya tenemos la lista creada, ahora se crea la clase donde se detallan las diferentes

funciones para la inserción, eliminación de un elemento o todos.

clase ListaEnlazada{ //esta llave abre la clase que se cerrara al final

public $primero = null;
prívate etatic $count = 0;
Declaradas las variables a usar, se procede a la creación de las funciones que realizan los

diferentes procesos.

- Función que cuenta los nodos dentro de la lista.

Public function ContarNodos(){

Return self::$count;
}

- Función que inserta un nodo

public function InsertarPrimerovacia ($elemento){

$this -> primero = new Nodo ($elemento);
$this -> próximo = null;
Self::$count++;
}

- Función que inserta un nodo en la primera posición de la lista.

public function InsertarPrimero ($elemento){

if ($this -> primero == null){
$this -> primero = new Nodo ($elemento);
} else {
$aux = new Nodo ($elemento);
$aux -> próximo = $this -> primero;
$this -> primero = $aux;
}
Self::$count++;
}

- Función que inserta un nodo en la última posición de la lista.

public function InsertarUltimo ($elemento){

if ($this -> primero == null){
$this -> primero = new Nodo ($elemento);
} else{
$actual = $this -> primero;
while ($actual -> próximo != null){
$actual = $actual -> próximo;
}
$actual -> próximo = new Nodo ($elemento);
}
Self::$count++;
}
- Función que inserta un nodo después de una posición dada.

public function InsertarDespues ($elemento, $key){

if ($key == 0){
$this -> InsertarPrimero ($elemento);
} else {
$aux = new Nodo ($elemento);
$actual = $this -> primero;
$anterior = $this -> primero;
For ($i=0;$i<$key;$i++){
$anterior = $actual;
$actual = $actual -> proximo;
}
$anterior -> proximo = $aux;
$aux -> proximo = $actual;
Self::$count++;
}
}

- Función que elimina el primer nodo de la lista.

public function EliminarPrimero(){

if ($this -> primero != null){
$actual = $this -> primero;
$this -> primero = $actual -> próximo;
}
Self::$count--;
}

- Función que elimina el nodo que ocupa la posición que sigue a la posición pasada por

el parámetro.

public function EliminarDespues($key){

if ($key == 0){
$this -> EliminarPrimero ($elemento);
} else{
$actual = $this  primero;
$anterior = $this -> primero;
for ($i=0; $i<$key; $i++){
$anterior = $actual;
$actual = $actual -> próximo;
}
$anterior -> próximo = $actual -> próximo;
Self::$count--;
}
}
 - Función que elimina el nodo cuyo dato coincide con el valor del parámetro.

public function EliminarNodo ($key){

$actual = $anterior = $this -> primero;
while ($actual -> dato != $key){
$anterior = $actual;
$actual = $actual -> próximo;
}
if ($actual == $anterior){
$this -> primero = $actual -> próximo;
}
$anterior -> próximo = $actual -> próximo;
Self::$count--;
}

- Función que recorre la lista desde el primer nodo hasta el último e imprime el dato

dentro del nodo.

public function ImprimirLista(){

$elementos = [];
$actual = $this -> primero;
while ($actual != null){
Array_push($elementos, $actual -> dato);
$actual = $actual -> próximo;
}
$str = ‘’;
foreach ($elementos as $elemento){
$str .= $elemento . ‘->’;
}
echo $str;
}
} //esta llave cierra la clase que contiene las funciones

Con esto terminamos las funciones que realizan los diferentes procesos solicitados, pero estas no

son nada si no se muestran los resultados de estas, para eso se ejecutarán e imprimirán las

diferentes funciones para mostrar los resultados.

Lo primero es crear la lista. Para esto primero creamos un array para ordenar los elementos pares

primeros e impares luego. Después llenamos la lista con estos datos del array resultante anterior.
Para el llenado de la lita se podría haber utilizado un foreach o un for, pero por tiempo se realizo

el ingreso manual.

$elementos = array(95, 6, 88, 32, 598, 63, 796, 45, 1, 158, 13, 86, 36, 59, 701);
$arrayPares=array();
$arrayImpares=array();
Foreach ($elementos as $elemento){
If ($elemento%2==0){

$arrayPares[]=$elemento;
}else{
$arrayImpares[]=$elemento;
}
}
$nuevoElementos=array_merge($arrayPares,$arrayImpares);
$lista=array();
$lista = new ListaEnlazada();
$lista->InsertarPrimerovacia($nuevoElementos[0]);
$lista->InsertarDespues($nuevoElementos[1],1);
$lista->InsertarDespues($nuevoElementos[2],2);
$lista->InsertarDespues($nuevoElementos[3],3);
$lista->InsertarDespues($nuevoElementos[4],4);
$lista->InsertarDespues($nuevoElementos[5],5);
$lista->InsertarDespues($nuevoElementos[6],6);
$lista->InsertarDespues($nuevoElementos[7],7);
$lista->InsertarDespues($nuevoElementos[8],8);
$lista->InsertarDespues($nuevoElementos[9],9);
$lista->InsertarDespues($nuevoElementos[10],10);
$lista->InsertarDespues($nuevoElementos[11],11);
$lista->InsertarDespues($nuevoElementos[12],12);
$lista->InsertarDespues($nuevoElementos[13],13);
$lista->InsertarUltimo($nuevoElementos[14]);

Al imprimir seria como sigue:

echo “Listado de Elementos Pares e Impares”;

$lista -> ImprimirLista();
Continuando con la parte 2 del control.

Eliminamos el primer elemento:

echo “Eliminación de Primer Elemento”;
$lista -> EliminarPrimero();
$lista -> ImprimirLista();

Vemos que el número 6 del listado de elementos que ocupaba la

primera posición ya no esta

Eliminamos el Último Elemento

echo "Se elimina Último Elemento";
$lista->EliminarNodo(701);
$lista->ImprimirLista();

Vemos que el número 701 del listado que ocupaba la última posición,
ya no está en el listado.

Eliminamos un elemento cualquiera, en este caso será el nodo 5.

echo "Se elemina Nodo 5";
$lista->EliminarDespues(5);
$lista->ImprimirLista();

Vemos ahora que el número 86 del listado, que usaba la posición

6 o el nodo 5, ya no se encuentra en el listado.

Ahora insertamos e imprimen 10 elementos más. Esto es insertado de forma manual.

echo "<br>Se Insertan 10 elementos.<br>";
$lista->InsertarDespues(200,12);
$lista->InsertarDespues(201,13);
$lista->InsertarDespues(202,14);
$lista->InsertarDespues(203,15);
$lista->InsertarDespues(204,16);
$lista->InsertarDespues(205,17);
$lista->InsertarDespues(206,18);
$lista->InsertarDespues(207,19);
$lista->InsertarDespues(208,20);
$lista->InsertarUltimo(209);
$lista->ImprimirLista();
Por último se procederá a vaciado de la lista.

Como no se podía utilizar vaciado de la lista usando algún recurso entregado, use eliminación
consecutiva del primer elemento.

for ($j=0; $j<22; $j++){

$lista->EliminarPrimero();
}
$lista->ImprimirLista();

Al imprimir no se observa ningún dato.

Código Completo
<?php
class Nodo
{
public $dato;
public $proximo;
public function __construct($elemento)
{
$this->dato = $elemento;
$this->proximo = null;
}
}
class ListaEnlazada
{
public $primero = null;
private static $count = 0;
public function ContarNodos()
{
return self::$count;
}
public function InsertarPrimerovacia($elemento) {
$this->primero = new Nodo($elemento);
$this->proximo = null;
self::$count++;
}
public function InsertarPrimero($elemento) {
if ($this->primero == null) {
$this->primero = new Nodo($elemento);
} else {
$aux = new Nodo($elemento);
$aux->proximo = $this->primero;
$this->primero = $aux;
}
self::$count++;
}
public function InsertarUltimo($elemento) {
if ($this->primero == null) {
$this->primero = new Nodo($elemento);
} else {
$actual = $this->primero;
while ($actual->proximo != null)
{
$actual = $actual->proximo;
}
$actual->proximo = new Nodo($elemento);
}
 self::$count++;
}
public function InsertarDespues($elemento,$key){
if($key == 0){
$this->InsertarPrimero($elemento);
}
else{
$aux = new Nodo($elemento);
$actual = $this->primero;
$anterior = $this->primero;
for($i=0;$i<$key;$i++)
{
$anterior = $actual;
$actual = $actual->proximo;
}
$anterior->proximo = $aux;
$aux->proximo = $actual;
self::$count++;
}
}
public function EliminarPrimero() {
if ($this->primero != null) {
$actual = $this->primero;
$this->primero = $actual->proximo;
}
self::$count--;
}
public function EliminarDespues($key){
if($key == 0){
$this->EliminarPrimero($elemento);
}
else{
$actual = $this->primero;
$anterior = $this->primero;
for($i=0;$i<$key;$i++)
{
$anterior = $actual;
$actual = $actual->proximo;
}
$anterior->proximo = $actual->proximo;
self::$count--;
}
}
public function EliminarNodo($key)
{
$actual = $anterior = $this->primero;
while($actual->dato != $key) {
 $anterior = $actual;
$actual = $actual->proximo;
}
if ($actual == $anterior) {
$this->primero = $actual->proximo;
}
$anterior->proximo = $actual->proximo;
self::$count--;
}
public function ImprimirLista()
{
$elementos = [];
$actual = $this->primero;
while($actual != null) {
array_push($elementos, $actual->dato);
$actual = $actual->proximo;
}
$str = '';
foreach($elementos as $elemento)
{
$str .= $elemento . '->';
}
echo $str;
}
}

$elementos = array(95, 6, 88, 32, 598, 63, 796, 45, 1, 158, 13, 86, 36, 59, 701);
$arrayPares=array();
$arrayImpares=array();
Foreach ($elementos as $elemento){
If ($elemento%2==0){
$arrayPares[]=$elemento;
}else{
$arrayImpares[]=$elemento;
}
}
$nuevoElementos=array_merge($arrayPares,$arrayImpares);
$lista=array();
$lista = new ListaEnlazada();
$lista->InsertarPrimerovacia($nuevoElementos[0]);
$lista->InsertarDespues($nuevoElementos[1],1);
$lista->InsertarDespues($nuevoElementos[2],2);
$lista->InsertarDespues($nuevoElementos[3],3);
$lista->InsertarDespues($nuevoElementos[4],4);
$lista->InsertarDespues($nuevoElementos[5],5);
$lista->InsertarDespues($nuevoElementos[6],6);
 $lista->InsertarDespues($nuevoElementos[7],7);
$lista->InsertarDespues($nuevoElementos[8],8);
$lista->InsertarDespues($nuevoElementos[9],9);
$lista->InsertarDespues($nuevoElementos[10],10);
$lista->InsertarDespues($nuevoElementos[11],11);
$lista->InsertarDespues($nuevoElementos[12],12);
$lista->InsertarDespues($nuevoElementos[13],13);
$lista->InsertarUltimo($nuevoElementos[14]);
echo "Listado de Elementos Pares e Impares";
echo "<br>";;
$lista->ImprimirLista();
echo "<br>";
echo "Se elimina Primer Elemento";
echo "<br>";
$lista->EliminarPrimero();
$lista->ImprimirLista();
echo "<br>";
echo "Se elimina Último Elemento";
echo "<br>";
$lista->EliminarNodo(701);
$lista->ImprimirLista();
echo "<br>";
echo "Se elemina Nodo 5";
echo "<br>";
$lista->EliminarDespues(5);
$lista->ImprimirLista();
echo "<br>";
echo "<br>Se Insertan 10 elementos.<br>";
$lista->InsertarDespues(200,12);
$lista->InsertarDespues(201,13);
$lista->InsertarDespues(202,14);
$lista->InsertarDespues(203,15);
$lista->InsertarDespues(204,16);
$lista->InsertarDespues(205,17);
$lista->InsertarDespues(206,18);
$lista->InsertarDespues(207,19);
$lista->InsertarDespues(208,20);
$lista->InsertarUltimo(209);
$lista->ImprimirLista();
echo "<br>";
echo "Se elimina Primer Elemento 2";
echo "<br>";
for ($j=0; $j<22; $j++){
$lista->EliminarPrimero();
}
$lista->ImprimirLista();
¿>
 Bibliografía

1.- Link 1

2.- Link 2

3.- Link 3

4.- Materialentregado