Estructura de datos

colas en C#

namespace cola
{
class colas
{
int[] vec;
int p, u, tam;
public colas(int n)
{
p = u = -1;
tam = n;
vec = new int[tam];
}
public bool agregar(int dato)
{
if(!esta_llena())
{
vec[++u]=dato;
if(u==0)
p=0;
return true;
}
return false;
}
public bool extraer(ref int dato)
{
if (!esta_vacia())
{
dato = vec[p];
if (p == u)
{
p = -1;
u = p;
}
else
p++;
return true;
}
return false;
}
public bool esta_llena()
{
if (u >= tam- 1)
return true;
return false;
}
public bool esta_vacia()
{
if (p == -1)
return true;
return false;
}
}
}

//-----------------------------------------------------

namespace cola

{

class Program

{

static void Main(string[] args)

{

colas cola = new colas(5);

int i;

Random r = new Random();

Console.WriteLine("agregar cola");

for (i = 0; i < 7; i++)

{

int dato = i + 5;

if (cola.agregar(dato))

Console.WriteLine("dato agregado" + dato);

else

Console.WriteLine("desbordamiento de la cola");

}

int d = 0;

Console.WriteLine("extrayendo datos");

if (cola.extraer(ref d))

Console.WriteLine("dato extraido" + d);

else

{

Console.WriteLine("sub desbordamiento la cola esta vacia");

}

Console.ReadKey();

}

Notación polaca y usando pila con Template

namespace notacion_polaca
{
enum Simbolo { OPERANDO, PIZQ, PDER, SUMRES, MULDIV, POW, };
class Not_Polaca
{
int cuantosp;
public Simbolo Tipo_y_Precedencia(char s)
{
Simbolo simbolo;
switch(s)
{
case '+': simbolo = Simbolo.SUMRES; break;
case '-': simbolo = Simbolo.SUMRES; break;
case '/': simbolo = Simbolo.MULDIV; break;
case '*': simbolo = Simbolo.MULDIV; break;
case '^': simbolo = Simbolo.POW; break;
case '(': simbolo = Simbolo.PIZQ; break;
case ')': simbolo = Simbolo.PDER; break;

default: simbolo = Simbolo.OPERANDO; break;
}
return simbolo;
}
public StringBuilder ConvertPosFija(string Ei)
{
cuantosp = 0;
int tam = Ei.Length;
char[] Epos = new char[tam];
Pila<char> stack = new Pila<char>(tam);
int i, pos = 0;
for (i = 0; i < Epos.Length; i++)
{
char car =Ei[i];
Simbolo actual = Tipo_y_Precedencia(car);
switch (actual)
{

case Simbolo.OPERANDO: Epos[pos++] = car; break;

case Simbolo.SUMRES:
{
while (!stack.Vacia && Tipo_y_Precedencia((char)stack.Tope()) >= actual)
Epos[pos++] = (char)stack.Pop();
stack.Push(car);
} break;

case Simbolo.MULDIV:
{
while (!stack.Vacia && Tipo_y_Precedencia((char)stack.Tope()) >= actual)
Epos[pos++] = (char)stack.Pop();
stack.Push(car);
} break;

case Simbolo.POW:
{
while (!stack.Vacia && Tipo_y_Precedencia((char)stack.Tope()) >= actual)
Epos[pos++] = (char)stack.Pop();
stack.Push(car);
} break;

case Simbolo.PIZQ:
{
stack.Push(car);
cuantosp++;
} break;


case Simbolo.PDER:
{
char x = (char)stack.Pop();
while (Tipo_y_Precedencia(x) != Simbolo.PIZQ)
{
Epos[pos++] = x;
x = (char)stack.Pop();
}
} break;
}
}
while (!stack.Vacia)
{//Porque esta ocasionando problemas con indice fuera de rango
if (pos < Epos.Length)
Epos[pos++] = (char)stack.Pop();
else
break;
}
StringBuilder regresa = new StringBuilder(Ei); //Epos.ToString();
for (int r = 0; r < Epos.Length; r++)
regresa[r] = Epos[r];
return regresa;
}
public double ResolverPosFija(StringBuilder Epos)
{
Epos.Length -= cuantosp;
int tam = Epos.Length;
Pila<double> stack = new Pila<double>(tam);

for (int i = 0; i < Epos.Length; i++)
{
char operador = Epos[i];
double num = operador - 48;
Simbolo actual = Tipo_y_Precedencia(operador);
switch (actual)
{
case Simbolo.OPERANDO: stack.Push(num); break;
case Simbolo.SUMRES:
{
if (operador == '+')
{
double num2 = stack.Pop();
stack.Push(stack.Pop() + num2);
}
else
{
double num1 = stack.Pop();
stack.Push(stack.Pop() + num1);
}
}break;
case Simbolo.MULDIV:
{
if (operador == '*')
{
double num2 = stack.Pop();
stack.Push(stack.Pop() * num2);
}
else
{
double num1 = stack.Pop();
stack.Push(stack.Pop() / num1);
}
}break;
case Simbolo.POW:
{
double num2 = stack.Pop();;
stack.Push(Math.Pow(stack.Pop(),num2));
}break;
}
}
return stack.Pop();
}
public string AnalizarCadena(string Ei)
{
int pos=1;
int tam = Ei.Length;
string cad = "falta";
for (int i = 0; i < tam; i++)
{
char car = Ei[i];
while(pos <= tam)
{
if (Ei[pos] != ')')
pos++;
else
cad += ")";
}
}
return cad;
}
}
}
//----------------------------------------------------------

class Pila<T>
{
//Atributos
T[] _pila;
int tam;
int tope;
bool vacia;
bool llena;
//Constructores
public Pila()
{
tam = 5;
tope = 0;
vacia = true;
llena = false;
_pila = new T[5];
}
public Pila(int MAX)
{
tam = MAX;
tope = 0;
vacia = true;
llena = false;
_pila = new T[MAX];
}
//Propiedades
public bool Llena
{
get { return llena;}
}
public bool Vacia
{
get{return vacia;}
}
//Metodos
public void Push(T dato)//Poner
{
vacia = false;
_pila[tope++] = dato;
if (tope == tam)
llena = true;
}
public T Pop()//Quitar
{
if (--tope == 0)
vacia = true;
llena = false;
return _pila[tope];
}
public T Tope()
{
return _pila[tope - 1];
}
}

Calculando con las clases Vector y Matriz

class Vector
{
int[] vec;

public Vector(int dim)
{
try
{
if (dim > 0)
vec = new int[dim];
else
vec = new int[5];
}
catch (FormatException ex)
{
Console.Write("Solo se aceptan numeros enteros positivos" + ex);
}
}

public int Mayor()
{
int mayor = vec[0];
//Inicializamos la variable i en 1 porque ya tenemos el dato en la posicion 0
for (int i = 1; i < vec.Length; i++)
if (mayor < vec[i])
mayor = vec[i];
return mayor;
}

public int Menor()
{
int menor = vec[0];
for (int i = 0; i < vec.Length; i++)
if (menor > vec[i])
menor = vec[i];
return menor;
}

public void Insertar()
{
Random ran = new Random();
for (int i = 0; i < vec.Length; i++)
vec[i] = ran.Next(1000, 10001);
}

public void Asignar(int val, int pos)
{
if (pos >= 0 && pos < vec.Length)
vec[pos] = val;
}

public int Leer(int pos)
{
return vec[pos];
}

//El uso del indexador suple los 2 metodos anteriores
public int this[int pos]
{
get { return vec[pos]; }
set { vec[pos] = value; }
}

public int Tamaño
{
get { return vec.Length; }
}

public void Leer()
{
for (int i = 0; i < vec.Length; i++)
Console.WriteLine(vec[i]);
}
}

//------------------------------------------------------------------------------------

class Matriz

{

int[,] mat;

int ren, col;

//Constructor

public Matriz(int r, int c)

{

ren = r;

col = c;

mat = new int[r, c];

}

public Matriz(DataGridView dg)

{

ren = dg.RowCount;

col = dg.ColumnCount;

mat = new int[ren, col];

for (int i = 0; i < dg.RowCount; i++)

for (int j = 0; j < dg.ColumnCount; j++)

mat[i, j] = Convert.ToInt32(dg.Rows[i].Cells[j].Value.ToString());

}

//Indexador

public int this[int r, int c]

{

get { return mat[r, c]; }

set { mat[r, c] = value; }

}

//Metodos

public double DiagonalPrinc()//int[,] m)

{

if (ren != col)

return 0.0;

double promedio = 0.0;

for (int r = 0; r < mat.GetLength(0); r++)

for (int c = 0; c < mat.GetLength(1); c++)

if (r == c)

promedio += mat[r, c];

return promedio / mat.GetLength(0);

}

public double DiagonalInv()//int[,] m)

{

if (ren != col)

return 0.0;

double prom = 0.0;

int _col = col - 1;

for (int i = 0; i < ren; i++)

prom += mat[i, _col--];

return prom / col;

}

//Propiedades

public int Renglones

{

get { return mat.GetLength(0); }

}

public int Columnas

{

get { return mat.GetLength(1); }

}

//Multiplicar matrices

static public Matriz operator *(Matriz a, Matriz b)

{

Matriz aux = new Matriz(a.ren, b.col);

for (int i = 0; i < a.ren; i++)

{

for (int j = 0; j < aux.col; j++)

{

aux[i, j] = 0;

for (int k = 0; k < aux.ren; k++)

aux[i, j] = aux[i, j] + a[i, k] * b[k, j];

}

return aux;

}

//--------------------------------------------------------------------

public partial class Form1 : Form

{

Matriz mat = new Matriz(5, 4);

Vector vec;

int[,] m = { { 194, 48, 206, 45 },

{ 180, 20, 310, 15 },

{88, 301, 90, 25},

{ 403, 70, 77, 32 },

{ 201, 88, 23, 55 }};

public Form1()

{

InitializeComponent();

}

private void Form1_Load(object sender, EventArgs e)

{

dgv1.RowCount = 5;

dgv1.ColumnCount = 5;

dgv2.RowCount = 1;

dgv2.ColumnCount = 5;

dgv3.RowCount = 1;

dgv3.ColumnCount = 4;

dgv1.Columns[0].HeaderCell.Value = "Distrito";

dgv1.Columns[1].HeaderCell.Value = "Candidato A";

dgv1.Columns[2].HeaderCell.Value = "Candidato B";

dgv1.Columns[3].HeaderCell.Value = "Candidato C";

dgv1.Columns[4].HeaderCell.Value = "Candidato D";

dgv2.Rows[0].HeaderCell.Value = "Votos";

dgv2.Columns[0].HeaderCell.Value = "Candidato A";

dgv2.Columns[1].HeaderCell.Value = "Candidato B";

dgv2.Columns[2].HeaderCell.Value = "Candidato C";

dgv2.Columns[3].HeaderCell.Value = "Candidato D";

dgv2.Columns[4].HeaderCell.Value = "Total de votos";

dgv3.Rows[0].HeaderCell.Value = "%";

dgv3.Columns[0].HeaderCell.Value = "Candidato A";

dgv3.Columns[1].HeaderCell.Value = "Candidato B";

dgv3.Columns[2].HeaderCell.Value = "Candidato C";

dgv3.Columns[3].HeaderCell.Value = "Candidato D";

for (int i = 0; i < 5; i++)

for (int j = 0; j < m.GetLength(1); j++)

{

mat[i, j] = m[i, j];

dgv1[0, i].Value = (i + 1).ToString();

dgv1[j + 1, i].Value = mat[i, j];

}

private void button1_Click(object sender, EventArgs e)

{

int aux = 0;

vec = new Vector(4);

for (int i = 0; i < vec.Tamaño; i++)

{

for (int j = 0; j < mat.Renglones; j++)

{

vec[i] += mat[j, i];

}

aux += vec[i];

dgv2[i, 0].Value = vec[i];

dgv2[4, 0].Value = aux;

}

double[] vector = new double[4];

for (int i = 0; i < dgv3.ColumnCount; i++)

{

vector[i] = ((double)vec[i] / aux) * 100;

dgv3[i, 0].Value = vector[i];

}

if (vector[0] >= 50)

MessageBox.Show("Ganador: Candidato A");

else

if (vector[1] >= 50)

MessageBox.Show("Ganador: Candidato B");

else

if (vector[2] >= 50)

MessageBox.Show("Ganador: Candidato C");

else

if (vector[3] >= 50)

MessageBox.Show("Ganador: Candidato D");

else

MessageBox.Show("No hay ganador");

}

Utilisando dos clases y Archivos

class Matriz
{
int[,] mat;
int ren, col;

//Constructor
public Matriz(int r, int c)
{
ren = r;
col = c;
mat = new int[r, c];
}

public Matriz(DataGridView dg)
{

ren = dg.RowCount;
col = dg.ColumnCount;
mat = new int[ren, col];
for (int i = 0; i < dg.RowCount; i++)
for (int j = 0; j < dg.ColumnCount; j++)
mat[i, j] = Convert.ToInt32(dg.Rows[i].Cells[j].Value.ToString());
}

//Indexador
public int this[int r, int c]
{
get { return mat[r, c]; }
set { mat[r, c] = value; }
}

//Metodos
public double DiagonalPrinc()//int[,] m)
{
if (ren != col)
return 0.0;
double promedio = 0.0;
for (int r = 0; r < mat.GetLength(0); r++)
for (int c = 0; c < mat.GetLength(1); c++)
if (r == c)
promedio += mat[r, c];
return promedio / mat.GetLength(0);
}

public double DiagonalInv()//int[,] m)
{
if (ren != col)
return 0.0;
double prom = 0.0;
int _col = col - 1;
for (int i = 0; i < ren; i++)
prom += mat[i, _col--];
return prom / col;
}

//Propiedades
public int Renglones
{
get { return mat.GetLength(0); }
}

public int Columnas
{
get { return mat.GetLength(1); }
}

//Multiplicar matrices
static public Matriz operator *(Matriz a, Matriz b)
{
Matriz aux = new Matriz(a.ren, b.col);
for (int i = 0; i < a.ren; i++)
{
for (int j = 0; j < aux.col; j++)
{
aux[i, j] = 0;
for (int k = 0; k < aux.ren; k++)
aux[i, j] = aux[i, j] + a[i, k] * b[k, j];
}
}
return aux;
}
}
//-----------------------------------------------------

class Vector
{
int[] vec;

public Vector(int dim)
{
try
{
if (dim > 0)
vec = new int[dim];
else
vec = new int[5];
}
catch (FormatException ex)
{
Console.Write("Solo se aceptan numeros enteros positivos" + ex);
}
}

public int Mayor()
{
int mayor = vec[0];
//Inicializamos la variable i en 1 porque ya tenemos el dato en la posicion 0
for (int i = 1; i < vec.Length; i++)
if (mayor < vec[i])
mayor = vec[i];
return mayor;
}

public int Menor()
{
int menor = vec[0];
for (int i = 0; i < vec.Length; i++)
if (menor > vec[i])
menor = vec[i];
return menor;
}

public void Insertar()
{
Random ran = new Random();
for (int i = 0; i < vec.Length; i++)
vec[i] = ran.Next(1000, 10001);
}

public void Asignar(int val, int pos)
{
if (pos >= 0 && pos < vec.Length)
vec[pos] = val;
}

public int Leer(int pos)
{
return vec[pos];
}

//El uso del indexador suple los 2 metodos anteriores
public int this[int pos]
{
get { return vec[pos]; }
set { vec[pos] = value; }
}

public int Tamaño
{
get { return vec.Length; }
}

public void Leer()
{
for (int i = 0; i < vec.Length; i++)
Console.WriteLine(vec[i]);
}
}

//-----------------------------------------------------------------

public partial class Form1 : Form

{

int[,] aux ={{0,2,0,3,7},

{1,0,0,4,9},

{8,0,2,5,1},

{9,0,8,0,0},

{0,0,0,0,1}};

Matriz mat;

public Form1()

{

InitializeComponent();

}

static private void LeerArchivo(string nomarch, int ren, int col, Matriz mat)

{

BinaryReader br = null;

try

{

if (File.Exists(nomarch))

{

br = new BinaryReader(new FileStream(nomarch, FileMode.Open, FileAccess.Read));

for (int r = 0; r < ren; r++)

for (int c = 0; c < col; c++)

{

int dato = br.ReadInt32();

mat[r, c] = dato;

}

else

MessageBox.Show("No existe el archivo");

}

catch (EndOfStreamException)

{

MessageBox.Show("Fin de archivo");

}

finally

{

if (br != null)

br.Close();

}

private void numericUpDown1_ValueChanged(object sender, EventArgs e)

{

dataGridView1.RowCount = dataGridView2.RowCount = Convert.ToInt32(numericUpDown1.Value);

}

private void numericUpDown2_ValueChanged(object sender, EventArgs e)

{

dataGridView1.ColumnCount = Convert.ToInt32(numericUpDown2.Value);

}

private void button1_Click(object sender, EventArgs e)

{

int ren = Convert.ToInt32(numericUpDown1.Value);

int col = Convert.ToInt32(numericUpDown2.Value);

if ((ren >= 3 && ren <= 5) && (col >= 3 && col <= 5))

{

mat = new Matriz(ren, col);

Vector vec = new Vector(ren);

for (int r = 0; r < ren; r++)

{

int cont = 0;

for (int c = 0; c < col; c++)

{

mat[r, c] = aux[r, c];

dataGridView1.Rows[r].Cells[c].Value = mat[r, c];

if (mat[r, c] == 0)

cont++;

vec[r] = cont;

dataGridView2[0, r].Value = vec[r];

}

private void button2_Click(object sender, EventArgs e)

{

int ren = Convert.ToInt32(numericUpDown1.Value);

int col = Convert.ToInt32(numericUpDown2.Value);

if ((ren >= 3 && ren <= 5) && (col >= 3 && col <= 5))

{

mat = new Matriz(ren, col);

Vector vec = new Vector(ren);

// aqui le damos la direccion de un archivo

LeerArchivo("G:\\Examen1_Parte1\\jose.av", ren, col, mat);

for (int r = 0; r < ren; r++)

{

int cont = 0;

for (int c = 0; c < col; c++)

{

dataGridView1[c, r].Value = mat[r, c];

if (mat[r, c] == 0)

cont++;

vec[r] = cont;

dataGridView2[0, r].Value = vec[r];

}

Estructura de datos

colas en C#

Notación polaca y usando pila con Template

Calculando con las clases Vector y Matriz

Utilisando dos clases y Archivos

Datos personales

Archivo del blog