public List <Producto> Busqueda([FromForm] Producto dato)
{
ArbolB <Producto> .IniciarArbol("Productos", new StringToObject(Producto.StringToProducto), new ObjectToString(Producto.ProductoToString));
return(ArbolB <Producto> .Recorrido(dato, null, 1));
}
public void nuevoArbol()
{
arbol = new ArbolB(5);
}
public List <Producto> RecorridoInOrder()
{
ArbolB <Producto> .IniciarArbol("Productos", new StringToObject(Producto.StringToProducto), new ObjectToString(Producto.ProductoToString));
return(ArbolB <Producto> .Recorrido(null, null));
}
public void Agregar([FromForm] Producto dato)
{
ArbolB <Producto> .IniciarArbol("Productos", new StringToObject(Producto.StringToProducto), new ObjectToString(Producto.ProductoToString));
ArbolB <Producto> .InsertarArbol(dato);
}
/// <summary>
/// <para>Algoritmo creado por Moises Alonso</para>
/// Algoritmo de creación de árbol de expresion a traves de Expresión Regular
/// </summary>
/// <param name="RE"></param>
public void Tree(List <Datos.AllData> RE)
{
var prueba = new List <string>();
var stringer = string.Empty;
foreach (var item in RE)
{
prueba.Add(item.StringData);
stringer += item.StringData;
}
foreach (var item in RE)
{
if (item.StringData == "(")
{
Datos.Instance.PilaT.Push(item.StringData);
}
else if (item.StringData == ")")
{
while (Datos.Instance.PilaT.Count > 0 && Datos.Instance.PilaT.Peek() != "(")
{
if (Datos.Instance.PilaT.Count == 0)
{
throw new Exception("Faltan operadores");
}
if (Datos.Instance.PilaS.Count < 2)
{
throw new Exception("Faltan operadores");
}
var nodoTemp = new ArbolB();
nodoTemp.Dato = Datos.Instance.PilaT.Pop();
nodoTemp.Padre = null;
nodoTemp.HijoDerecho = Datos.Instance.PilaS.Pop();
nodoTemp.HijoDerecho.Padre = nodoTemp.Dato;
nodoTemp.HijoIzquierdo = Datos.Instance.PilaS.Pop();
nodoTemp.HijoIzquierdo.Padre = nodoTemp.Dato;
Datos.Instance.PilaS.Push(nodoTemp);
}
Datos.Instance.PilaT.Pop();
}
else if (Utilities.Op.Contains(item.StringData))
{
if (item.StringData == "?" || item.StringData == "*" || item.StringData == "+")
{
var nodoTemp = new ArbolB();
nodoTemp.Dato = item.StringData;
nodoTemp.Padre = null;
if (Datos.Instance.PilaS.Count == 0)
{
throw new Exception("Error, faltan operandos");
}
nodoTemp.HijoIzquierdo = Datos.Instance.PilaS.Pop();
nodoTemp.HijoIzquierdo.Padre = nodoTemp.Dato;
Datos.Instance.PilaS.Push(nodoTemp);
}
else if (Datos.Instance.PilaT.Count != 0)
{
while (Datos.Instance.PilaT.Peek() != "(" && (VerificarPrecedencia(item.StringData) == true))
{
var nodoTemp = new ArbolB();
nodoTemp.Dato = Datos.Instance.PilaT.Pop();
nodoTemp.Padre = null;
if (Datos.Instance.PilaS.Count() < 2)
{
throw new Exception("Faltan operadores");
}
else
{
var precedencia = VerificarPrecedencia(item.StringData);
nodoTemp.HijoDerecho = Datos.Instance.PilaS.Pop();
nodoTemp.HijoDerecho.Padre = nodoTemp.Dato;
nodoTemp.HijoIzquierdo = Datos.Instance.PilaS.Pop();
nodoTemp.HijoIzquierdo.Padre = nodoTemp.Dato;
Datos.Instance.PilaS.Push(nodoTemp);
}
}
}
if (item.StringData == "|" || item.StringData == ".")
{
Datos.Instance.PilaT.Push(item.StringData);
}
}
else
{
var nodoTemp = new ArbolB();
nodoTemp.Dato = item.StringData;
nodoTemp.Padre = null;
Datos.Instance.PilaS.Push(nodoTemp);
}
}
while (Datos.Instance.PilaT.Count > 0)
{
if (Datos.Instance.PilaT.Peek() == "(" || Datos.Instance.PilaS.Count < 2)
{
throw new Exception("Faltan operadores");
}
var nodoTemp = new ArbolB();
nodoTemp.Dato = Datos.Instance.PilaT.Pop();
nodoTemp.Padre = null;
nodoTemp.HijoDerecho = Datos.Instance.PilaS.Pop();
nodoTemp.HijoDerecho.Padre = nodoTemp.Dato;
nodoTemp.HijoIzquierdo = Datos.Instance.PilaS.Pop();
nodoTemp.HijoIzquierdo.Padre = nodoTemp.Dato;
Datos.Instance.PilaS.Push(nodoTemp);
}
if (Datos.Instance.PilaS.Count != 1)
{
throw new Exception("Faltan operadores");
}
}
public ActionResult Dividir(string Codigo)
{
string CodigoN = Codigo;
string[] CodigoSeparado = new string[100];
CodigoSeparado = CodigoN.Split(' ');
if (CodigoSeparado[0] == "CREATE" && DiccionarioArboles.ContainsKey(CodigoSeparado[2]) == false)
{
if (CodigoSeparado[1] == "TABLE")
{
ArbolNuevo.NombreVariables.Clear();
Ingresados.Clear();
int ContadorAtributos = (CodigoSeparado.Length - 7) / 2; //-7 por CREATE TABLE NOMBRE ID INT PRIMARY KEY y DIV 2 porque por cada nombre existe un tipo de variable
//AtributosDeTabla = new string[CodigoSeparado.Length - 7]; //Arreglo para guardar todos los atributos y sus tipos
if (ContadorAtributos > 10)
{
return(RedirectToAction("/error"));
}
else
{
ArbolNuevo.NombreVariables.Add("ID");
for (int i = 7; i < CodigoSeparado.Length; i++) //Desde 7 para que comienze luego de KEY
{
if (i % 2 != 0)
{
ArbolNuevo.NombreVariables.Add(CodigoSeparado[i]); //i-7 para comenzar en 0 en AtributosDeTabla
}
}
//en posiciones pares se almacenara el nombre y en posiciones impares el tipo de dato
DiccionarioArboles.Add(CodigoSeparado[2], ArbolNuevo);
ViewBag.Columnas = ArbolNuevo.NombreVariables;
return(View());
}
}
else
{
return(RedirectToAction("/error"));
}
}
else if (CodigoSeparado[0] == "INSERT" && CodigoSeparado[1] == "INTO") //Revisa sintaxis
{
if (DiccionarioArboles.ContainsKey(CodigoSeparado[2]) == true) //Revisa que si exista la tabla
{
int Declarados = 0; //Contador de atributos declarados antes de "VALUES"
int PosicionValues = 0; //Posicion de vector CodigoSeparado[] donde esta "VALUES"
int Asignados = 0; //Contador de variables asignadas despues de "VALUES"
for (int i = 0; i < CodigoSeparado.Length; i++) //Para contar atributos
{
if (CodigoSeparado[i] == "VALUES")
{
PosicionValues = i; //Toma valor de posicion donde VALUES esta
break;
}
}
Declarados = PosicionValues - 3; //Resta 3 de la posicion VALUES por "INSERT", "INTO" y "VALUES"
for (int j = (PosicionValues + 1); j < CodigoSeparado.Length; j++) //Comienza despues de VALUES
{
Asignados++; //Incrementa por elementos
}
if (Declarados != Asignados)
{
return(RedirectToAction("/error"));
}
if (Declarados > 10)
{
return(RedirectToAction("/error"));
}
if (Asignados == Declarados)
{
string[] Columnas = new string[Declarados]; //Arreglo para imprimir columnas
string[] As = new string[Declarados]; //Arreglo para imprimir declarados
for (int p = 3; p < PosicionValues; p++) //Desde posicion 3 para quitar INSERT INTO Nombre, hasta VALUES
{
Columnas[p - 3] = CodigoSeparado[p]; //Recorre CodigoSeparado para ingresar en Columnas
}
for (int p = PosicionValues + 1; p < CodigoSeparado.Length; p++) //Desde uno luego de VALUES
{
As[p - PosicionValues - 1] = CodigoSeparado[p]; //Recorre CodigoSeparado para guardar los asignados
}
Informacion Datos = new Informacion(); //Se instancia un dato de tipo informacion para poder guardarlo en arbol
Datos.IDregistro = int.Parse(As[0]); //Agrega ID
/*foreach (var item in As) //Agrega cada valor en la lista de registros
* {
* Datos.Registros.Add(item);
* }
* DiccionarioArboles[CodigoSeparado[2]].InsertarNodo(DiccionarioArboles[CodigoSeparado[2]].Raiz, Datos);
* Ingresados.Add(As);
*
* Ingresados = Ingresados.OrderBy(o => o[0]).ToList();
* ViewBag.Columnas = ArbolNuevo.NombreVariables;
* ViewBag.Insertado = Ingresados;*/
return(View());
}
}
else
{
return(RedirectToAction("/error"));
}
}
if (CodigoSeparado[0] == "SELECT")
{
int Marcador = 0; //Posicion de FROM en arreglo CodigoOrdenado
for (int i = 0; i < CodigoSeparado.Length; i++)
{
if (CodigoSeparado[i] == "FROM") //Desde 1 para quitar el SELECT
{
Marcador = i; //Obtiene la posicion de FROM
}
}
string[] ColumnasSelecionadas = new string[Marcador - 1]; //Cantidad de columnas selecionadas sera la posicion del marcador menos uno
for (int i = 1; i < ColumnasSelecionadas.Length; i++)
{
ColumnasSelecionadas[i - 1] = CodigoSeparado[i]; //Almacena solo las "categorias" que el usuario escribio para obtener
}
return(RedirectToAction("/exito"));
}
else if (CodigoSeparado[0] == "DELETE" && CodigoSeparado[1] == "FROM")
{
bool TieneWhere = false;
Informacion ID = new Informacion();
if (DiccionarioArboles.ContainsKey(CodigoSeparado[3]) == true)
{
for (int i = 0; i < CodigoSeparado.Length; i++) //Busca si el codigo tiene "where"
{
if (CodigoSeparado[i] == "WHERE")
{
TieneWhere = true;
}
}
if (TieneWhere == false)
{
DiccionarioArboles[CodigoSeparado[2]].EliminarArbol();
}
else
{
ID.IDregistro = Convert.ToInt32(CodigoSeparado[6]);
DiccionarioArboles[CodigoSeparado[3]].Eliminar(ID, DiccionarioArboles[CodigoSeparado[3]].Raiz);
}
}
foreach (var Vector in Ingresados) //Para eliminar de la vista (del viewbag)
{
if (Vector[0] == CodigoSeparado[6])
{
Ingresados.Remove(Vector);
}
}
Ingresados = Ingresados.OrderBy(o => o[0]).ToList();
return(View());
}
else if (CodigoSeparado[0] == "DROP")
{
if (CodigoSeparado[1] == "TABLE")
{
string NombreTabla = CodigoSeparado[2];
if (DiccionarioArboles.ContainsKey(NombreTabla) == true)
{
DiccionarioArboles.Remove(NombreTabla);
Ingresados = null;
ArbolNuevo = null;
return(View("Inicio"));
}
else
{
return(RedirectToAction("/error"));
}
}
else
{
return(RedirectToAction("/error"));
}
}
else
{
return(RedirectToAction("/error"));
}
}
public static void Comprimir(string nombre)
{
Directory.CreateDirectory("temp");
ArbolB <ProductData> .IniciarArbol(nombre, null, null);
using (var streamReader = new FileStream($"Datos\\{nombre}.txt", FileMode.Open))
{
using (var reader = new BinaryReader(streamReader))
{
using (var streamWriter = new FileStream($"temp\\{nombre}.txt", FileMode.OpenOrCreate))
{
using (var writer = new BinaryWriter(streamWriter))
{
var DiccionarioLetras = new Dictionary <string, string>();
var bufferLength = 10000;
var bytebuffer = new byte[bufferLength];
var stringLetra = string.Empty;
while (reader.BaseStream.Position != reader.BaseStream.Length)
{
bytebuffer = reader.ReadBytes(bufferLength);
for (int i = 0; i < bytebuffer.Count(); i++)
{
stringLetra = Convert.ToString(Convert.ToChar(bytebuffer[i]));
if (!DiccionarioLetras.ContainsKey(stringLetra))
{
var stringnum = Convert.ToString(DiccionarioLetras.Count() + 1, 2);
DiccionarioLetras.Add(stringLetra, stringnum);
stringLetra = string.Empty;
}
}
}
writer.Write(Encoding.UTF8.GetBytes(Convert.ToString(DiccionarioLetras.Count).PadLeft(8, '0').ToCharArray()));
foreach (var fila in DiccionarioLetras)
{
writer.Write(Convert.ToByte(Convert.ToChar(fila.Key[0])));
}
reader.BaseStream.Position = 0;
stringLetra = string.Empty;
var anterior = string.Empty;
var ListaCaracteres = new List <string>();
while (reader.BaseStream.Position != reader.BaseStream.Length)
{
bytebuffer = reader.ReadBytes(bufferLength);
for (int i = 0; i < bytebuffer.Count(); i++)
{
stringLetra += Convert.ToString(Convert.ToChar(bytebuffer[i]));
if (!DiccionarioLetras.ContainsKey(stringLetra))
{
var stringnum = Convert.ToString(DiccionarioLetras.Count() + 1, 2);
DiccionarioLetras.Add(stringLetra, stringnum);
ListaCaracteres.Add(DiccionarioLetras[anterior]);
anterior = string.Empty;
anterior += stringLetra.Last();
stringLetra = anterior;
}
else
{
anterior = stringLetra;
}
}
}
ListaCaracteres.Add(DiccionarioLetras[stringLetra]);
var cantMaxBits = Math.Log2((float)DiccionarioLetras.Count);
cantMaxBits = cantMaxBits % 1 >= 0.5 ? Convert.ToInt32(cantMaxBits) : Convert.ToInt32(cantMaxBits) + 1;
writer.Write(Convert.ToByte(cantMaxBits));
for (int i = 0; i < ListaCaracteres.Count; i++)
{
ListaCaracteres[i] = ListaCaracteres[i].PadLeft(Convert.ToInt32(cantMaxBits), '0');
}
var bufferEscritura = new List <byte>();
var aux = string.Empty;
foreach (var item in ListaCaracteres)
{
aux += item;
if (aux.Length >= 8)
{
var max = aux.Length / 8;
for (int i = 0; i < max; i++)
{
bufferEscritura.Add(Convert.ToByte(Convert.ToInt32(aux.Substring(0, 8), 2)));
aux = aux.Substring(8);
}
}
}
if (aux.Length != 0)
{
bufferEscritura.Add(Convert.ToByte(Convert.ToInt32(aux.PadRight(8, '0'), 2)));
}
writer.Write(bufferEscritura.ToArray());
}
}
}
}
}
