Skip to content

Latest commit

 

History

History
461 lines (404 loc) · 12.2 KB

Vectores.md

File metadata and controls

461 lines (404 loc) · 12.2 KB
Raw

📚Vectores


Indice

Asignación_de_contenido

var
  numero:integer;
  v:vector;
begin
  numero:=10;
  v[4]:=numero;
end.

Lectura_Escritura

var
  v:vector;
begin
  readln(v[1);
  writeln(v[1];
end.

Recorridos

La operacion de Recorridos en un vector consiste en recorrer el vector de manera total o parcial, para realizar algún proceso sobre sus elementos.

  • Recorrido Total Implica analizar todos los elementos del vector, lo que lleva a recorrer completamente la estructura.
  • Recorrido Parcial Implica analizar los elementos del vector, hasta encontar aquel que cumple con lo pedido. Puede ocurrir que se recorra todo el vector.
Recorrido Total Recorrido Parcial Recorrido Parcial 2 
var
    v:vector;
    i:integer;
begin
    for i:=1 to dimF do
       writeln(v[i]);
end.
 
var //(Seguro Existe)
    v:vector;
    i:integer;
begin
    i:=1;
    while (v[i] <> 0) do
    begin
       writeln(v[i]);
       i:=i+1;
    end;
end.
 
var //(Puede no Existir)
    v:vector;
    i:integer;
begin
    i:=1;
    while (i <= dimF) and (v[i] <> 0) do
    begin
       i:=i+1;
    end;
    if (i <= dimF ) then
       writeln ('Existe');
    else
       writeln ('No Existe');
end.

Cargar_Datos

La operacion de Cargar Datos en un vector consiste en incorporar un elemento a continuacion del otro desde la posición inicial en forma consecutiva.

  • Carga Total Consiste en guardar cada elemento en una posición del vector.
  • Carga Parcial Esta operación debe controlar que la cantidad de elementos que se cargan no supere la dimensión física.
Carga Total Carga Parcial 
procedure Carga_Total(var v:vector);
var
    i:integer;
begin
    for i:=1 to dimF do
    begin
       readln(v[i]);                    
    end;
end.
 
procedure Carga_Parcial(var v;vector;var dimL);
var
    numero:integer;
begin
    dimL:=0;
    readln(numero);
    while (numero <> 0) and (dimL < dimF) do
    begin
       dimL:=dimL+1;
       v[dimL]:=nummero;
       readln(numero);                 
    end;
end.

Agregar_al_final

Para agregar al final del vector solo tenemos que verificar que tengamos espacio en el vector, aumentamos en uno la dimension logica y lo agregamos.

Procedure Agregar_Al_Final(var v:vector;var dimL:integer;elemeto:integer);
begin
   if (dimL < dimF) then 
   begin
      dimL:=dimL + 1; 
      v[dimL]:=elemento;
   end;
end.

Insertar_un_elemento

La operación de insertar un elemento en un vector consiste en incorporar el elemento en una posición determinada o de acuerdo a un orden impuesto por sus datos (ej: ordenada de mayor a menor).

Posición_Determinada

Consiste en guardar cada elemento en una posición del vector.

  • Verificar la posición a insertar.
  • Verificar espacio en el vector.
  • Abrir el vector (a partir de la dimL)
  • Aumentar la dimL
procedure Posicion_Determinada (var v:vector; var dimL:integer;elemento,pos:integer);
var
   i:integer;
begin
    if (dimL < dimF) and ((pos >= 1) and (pos <= dimL)) then
    begin
         for i:=dimL to downto pos to
            v[i + 1] := v[i];
         v[pos]:=elemento;
         dimL:=dimL+1;
    end;
end;

Manteniendo_Un_Orden

Esta operación requiere verificar el espacio disponible, buscar la posición correspondiente manteniendo el orden y luego insertar el elemento en el vector.

  • Verificar espacio en el vector
  • Determinar posición donde se inserta.
  • Insertar elemento en la posición determinada.
//Insertar un elemento en un vector ordenado de menor a mayor
procedure Manteniendo_un_Orden (var v:vector; var dimL:integer;elemento:integer);
var
    pos:integer;
begin
    if (dimL < dimF) then
    begin
        pos:=BuscarPosicion(elemento,v,dimL);
        Insertar(v,dimL,pos,elemento);
    end;
end;
//__________________________________________________________________________________
Function BuscarPosicion (x:integer;v:vector;dimL:integer):integer;
var
    pos:=Integer;
begin
    pos:=1; 
    while (pos <= dimL) and (x > v[pos]) do
        pos:=pos + 1;
    BuscarPosicion:=pos;
end;
//__________________________________________________________________________________
Procedure Insertar (var v:vector; var dimL:integer; pos: Indice; elem:integer);
var 
    i: indice;
begin
    for i:= dimL downto pos do 
        v [i + 1] := v [i] ;
    v [pos] := elem; 
    dimL := dimL + 1;
End;

Borrar_Elementos

La operación Borrar un elemento en un vector consiste en eliminar un elemento determinado o bien eliminar un elemento que ocupa una posición determinada.

En_Posición_Determinada

Se debe verificar que la posición sea valida.

  • Validar la posición a eliminar.
  • Desplazar elementos (A partir de la siguiente posición).
  • Abrir el vector (a partir de la dimL)
  • Disminuir la dimL
Procedure BorrarPos (var v: vector; var dimL: integer; pos: posicion);
var 
    i: integer; 
Begin
    if (pos >=1 and pos <= dimL) then 
    begin
        for i:= pos + 1 to dimL  do
            v [ i - 1 ]  :=  v [ i ] ;
        dimL := dimL - 1 ;         
   end;
End;

Elemento_Determinado

Hay que verificar que exista el elemento.

  • Buscar la posición del elemento a borrar.
  • Si el elemento esta entonces ----> Borrar el elemento.
Procedure BorrarElem (var v: vector;  var dimL: integer; elem: integer);
var 
    pos: indice;
begin
    pos:= BuscarPosElem (elem, v, dimL);
    if (pos <> 0) then 
    begin
        BorrarPos (v, dimL, pos);
   end;
end;
//__________________________________________________________________________________
Function BuscarPosElem (x:integer; v:vector; dimL: integer): integer;
var 
    pos:integer; 
    exito: boolean;
Begin
    pos:=1; 
    exito:= false;
    while (pos <= dimL) and (not exito) do 
    begin
        if (x = v[pos]) then
            exito:= true
        else
            pos:=pos+1;
    end;
    if (exito = false) then 
        pos:=0;
    BuscarPosElem:= pos;
end; 
//__________________________________________________________________________________
Procedure BorrarPos (var v:vector; var dimL:integer; pos:integer);
var 
    i: integer; 
Begin
    for i:= pos + 1  to   dimL  do
        v [ i - 1 ]  :=  v [ i] ;
    dimL := dimL - 1 ;         
End;

Buscar_elemento

El proceso de ubicar información particular en una colección de datos es conocido como método de busqueda.

Busqueda_Lineal_o_Secuencial

Almacenados sin ningun orden.

  • Se aplica cuando los elementos no tienen orden.

  • Requiere excesivo consumo de tiempo en la localización del elemento.

  • Numero medio de compareciones (dimL + 1) / 2.

  • Es ineficiente a medida que el tamaño del arreglo crece.

  • La búsqueda compienza desde el principio y se avanza por la estructura de manera secuencial, uno a uno.

  • La solución debería recorrer el vector y detenerse en caso de encontrar el elemento X.

Function BuscarPosElem (x:integer;v:vector;dimL:integer):integer;
var 
    pos:integer; 
    exito: boolean;
Begin
    pos:=1;
    exito:= false;
    while (pos <= dimL) and (not exito) do
    begin
        if (x = v[pos]) then
            exito:= true
        else
            pos:=pos+1;
    end;
    if (exito = false) then 
        pos:=0;
    BuscarPosElem:= pos;
end;

En_arreglos_ordenados

Almacenados ordenados por algun criterio.

Secuencial_Optimizado

  • Se aplica cuando los elementos tienen orden.
  • La busqueda comienza desde el pricipio y se avanza por la estructura de manera secuencial y asi hasta que encuentro el número buscado o hasta que encuentro uno mayor.
Function BuscoPosElemOrd (x:integer;v:Vector;dimL:integer):integer;
var 
    pos:integer;
Begin
    pos:=1;
    while (pos <= dimL) and (x > v[pos]) do
        pos:=pos+1;
    if ( pos > dimL ) or (x < v [pos]) then //Si me pase de la DimL del vector reincicio la posición
        pos:=0;                               //y si el elemento es mas chico que el menor numero del vector, tambien reinicio.
    BuscoPosElemOrd:= pos;
End;

Busqueda_Dicotomica

  • Se aplica cuando los elementos tienen orden.
  • Se compara el valor buscado x con el ubicado en el medio del vector a:
    • Si el elemento ubicado al medio del vector es igual a x, entonces la busqueda termina.
    • Si no es el valor buscado, debera quedarse con la mitad del vector que conviene, para seguir la busqueda. Este paso se repite tantas veces hasta que se acaba el vector o encuentro el valor.
  • Se calcula la posición del medio del vector original.
  • Se descarta la primera parte.
  • Se calcula la posición del medio del sub_arreglo de:
  • Se descarta la Segunda parte del subarrango (de 7 a 9).
  • Se calcula la posición del medio del subarrango delimitado por:
Procedure  BusquedaBin (var v: Vector; var j:integer; dimL,x: integer);
Var //En caso de que este ordenada de menor a mayor.
    primero, ult, medio: integer;
Begin
    j :=0 ;
    primero:= 1;
    ult:= dimL;
    medio := (primero + ult ) div 2 ; //Calculo la posición del medio
    While ( primero < = ult ) and ( x <> v [medio]) do 
    begin//Mientras no llegue al final y el elemento sea distinto al elemento que esta en la posicion del medio.
        If ( x < v [ medio ] ) then //Si es mas chico 
            ult:= medio -1 ; //Descarto la segunda mitad del arreglo y comienzo a restar a partir de la primera mitad
        else
            primero:= medio+1 ; //Si es mas grande, continuo a partir de la segunda mitad del arreglo
        medio := ( primero + ult ) div 2 ; //Actualizo el elemento del medio para continuar mi recorrido.
    end;
    If (primero < = ult) then //Si se encontro vale el valor medio
        j := medio
    else
        j := 0;
End;

Corte_de_Control

Procedure CorteDeControl(var v:vector;var dimL:integer);
var
    numero:integer;
    num_aux:Integer;
    cantidad:integer;
begin
    ReadLn(numero);
    dimL:=0;
    while ((numero <> -1) and (dimL < dimF)) do
    begin
        cantidad:=0;
        num_aux:=numero;
        while (numero = num_aux) do
        begin
            cantidad:=cantidad+1;
            dimL:=dimL+1;
            ReadLn(numero);
            v[dimL]:=numero;
        end;
        WriteLn('La cantidad de',numero,' es ', cantidad);
    end;
end;