📚Vectores

Indice

• Asignación de contenido
• Lectura/Escritura
• Recorridos
• Carga de datos
• Agregar al Final
• Insertar Elementos
  • En una Posición Determinada
  • Manteniendo un orden
• Borrar Elementos
  • En una Posición Determinada
  • Un Elemento Determinado
• Buscar un elemento
  • Busqueda Lineal o Secuencial
  • Busqueda en arreglos ordenados
    • Secuencial Optimizado
    • Busqueda Dicotomica
• Corte de control

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
```Pas var v:vector; i:integer; begin for i:=1 to dimF do writeln(v[i]); end. ```	```Pas var //(Seguro Existe) v:vector; i:integer; begin i:=1; while (v[i] <> 0) do begin writeln(v[i]); i:=i+1; end; end. ```	```Pas 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
```Pas procedure Carga_Total(var v:vector); var i:integer; begin for i:=1 to dimF do begin readln(v[i]); end; end. ```	```Pas 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;