Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

ESTRUCUTURAS DE DATOS

Un vector es una estructura de datos que permite almacenar un conjunto de datos del mismo tipo con unico nombre con el define el vector y por medio del subindice hacemos referencia a cada elemento de dicho conjunto en este caso un vector
by

Roanld Fabian Melo Aldana

on 9 October 2012

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of ESTRUCUTURAS DE DATOS

ESTRUCTURAS DE DATOS VECTORES. Permite almacenar un conjunto de datos del mismo tipo con único nombre con el define el vector y por medio del subíndice hacemos referencia a cada elemento de dicho conjunto en este caso un vector. EJEMPLO:
Si queremos guardar los sueldos de cinco empleados
Según lo conocido deberíamos definir 5 variables, si queremos tener en un cierto momento de los 5 sueldos almacenados en memoria.
Empleando un vector solo se requiere definir un único nombre y accedemos a cada elemento por medio del subíndice. MATRICES.

Una matriz es un conjunto de elementos
continuos, todos del mismo tipo, que comparten un nombre común y a los que es posible acceder mediante la posición que ocupa cada uno de ellos en la matriz, Esta permitirá escribir código más simple. PILAS. Las filas y columnas comienzan a enumerarse a partir de cero, similar a los vectores.
Una matriz se la puede representar por un conjunto de vectores.
Una pila es una estructura de datos en la que el ultimo elemento en entrar es el primero en salir, por lo que también se denominan estructura LIFO en esta estructurada solo se tiene acceso a la cabeza o cima de la pila. Las estructuras de datos es la forma de organizar una colección de datos para prevenir o solucionar un problema en cuanto la programación En conclusión, una estructura de datos es una manera de disponer de una colección de datos, al igual de la forma en cómo van a ser manipulados. LISTAS. Es un TAD que nos permite almacenar datos de una forma organizada, al igual que los vectores pero, a diferencia de estos, esta estructura es dinámica, por lo que no tenemos que saber a "priori" los elemento que puede contener, los elementos también suelen recibir también en nombre de nodos de la lista. import java.util.Scanner;
public class PruebaVector1 {
private Scanner teclado;
private int[] sueldos;
public void cargar()
{
teclado=new Scanner(System.in);
sueldos=new int[5];
for(int f=0;f<5;f++) {
System.out.print("Ingrese valor de la componente:");
sueldos[f]=teclado.nextInt();
}
}
public void imprimir() {
for(int f=0;f<5;f++) {
System.out.println(sueldos[f]);
}
}
public static void main(String[] ar) {
PruebaVector1 pv=new PruebaVector1();
pv.cargar();
pv.imprimir();
}
} import java.util.Scanner;
public class Matriz1 {
private Scanner teclado;
private int[][] mat;
public void cargar() {
teclado=new Scanner(System.in);
mat=new int[3][5];
for(int f=0;f<3;f++) {
for(int c=0;c<5;c++) {
System.out.print("Ingrese componente:");
mat[f][c]=teclado.nextInt();
}
}
}
public void imprimir() {
for(int f=0;f<3;f++) {
for(int c=0;c<5;c++) {
System.out.print(mat[f][c]+" ");
}
System.out.println();
}
}
public static void main(String[] ar) {
Matriz1 ma=new Matriz1();
ma.cargar();
ma.imprimir();
}
} Pilas son como una pila de libros, los primero que entran a la pila son los últimos en salir por que quedan debajo delos demás. pila CREAR (int tamanoMax)
{
pila P;

P = (pila) malloc(sizeof(tipoPila));
if (P == NULL)
error("No hay memoria suficiente");
P->Lmax = tamanoMax;
P->tope = -1;
P->elementos = (tElemento *) malloc(tamanoMax, sizeof(tElemento));
if (P->elementos == NULL)
error("No hay memoria suficiente.");
return P;
}

void DESTRUIR (pila *P)
{
free((*P)->elementos);
free(*P);
*P = NULL;
}

int VACIA (pila P)
{
return(P->tope == -1);
}

tElemento TOPE (pila P)
{
if (VACIA(P)) {
error("No hay elementos en la pila.");
return(P->elementos[P->tope]);
}

void POP (pila P)
{
if (VACIA(P)) {
error("No hay elementos en la pila.");
P->tope--;
}

void PUSH (tElemento x, pila P)
{
if (P->tope==P->Lmax-1) {
error("Pila llena");
p->tope++;
p->elementos[p->tope] = x;
} pila CREAR (int tamanoMax)
{
pila P;
P = (pila) malloc(sizeof(tipoPila));
if (P == NULL)
error("No hay memoria suficiente");
P->Lmax = tamanoMax;
P->tope = -1;
P->elementos = (tElemento *) malloc(tamanoMax, sizeof(tElemento));
if (P->elementos == NULL)
error("No hay memoria suficiente.");
return P;
}
void DESTRUIR (pila *P)
{
free((*P)->elementos);
free(*P);
*P = NULL;
}
int VACIA (pila P)
{
return(P->tope == -1);
}
tElemento TOPE (pila P)
{
if (VACIA(P)) {
error("No hay elementos en la pila.");
return(P->elementos[P->tope]);
}
void POP (pila P)
{
if (VACIA(P)) {
error("No hay elementos en la pila.");
P->tope--;
}
void PUSH (tElemento x, pila P)
{
if (P->tope==P->Lmax-1) {
error("Pila llena");
p->tope++;
p->elementos[p->tope] = x;
} Una cola es una estructura de datos donde el primer elemento en entrar es el primero en salir también denominadas estructuras FIFO
Esta estructura de datos s e puede definir como una lista enlazada con acceso FIFO a la que solo tiene acceso o al final de la lista para meter elementos y al principio de esta para sacarlos Un árbol es una estructura no lineal en la que cada nodo puede apuntar a uno o varios nodos.
También se suele dar una definición recursiva: un árbol es una estructura en compuesta por un dato y varios árboles.
Esto son definiciones simples. Pero las características que implican no lo son tanto. colas ARBOLES GRAFOS Representa el dato a almacenar. Puede ser de cualquier tipo; en este ejemplo se trata de una lista de enteros.
Es un puntero al siguiente elemento de la lista; con este puntero enlazamos con el sucesor, de forma que podamos construir la lista.


Esquema de un nodo y una lista enlazada. #include <conio.h>
#include <iostream.h>
void Recorrido(char Info[8][2],int Indice[8],int Inicio,int Disp);
void main()
char Info[8][2]={{"G"},{"I"},{" "},{"T"},{"O"},{"A"},
{" "},{"T"}};
int Indice[8]={5,7,6,1,-999,3,-999,4};
int Inicio=0,Disp=2;
cout<<"El Recorrido es:\n";
Recorrido(Info,Indice,Inicio,Disp);
getch();
}
void Recorrido(char Info[8][2],int Indice[8],int Inicio,int Disp)
{
int Apuntador=Inicio;
while(Apuntador!=-999)
{
cout<<Info[Apuntador];
Apuntador=Indice[Apuntador];
}
} Un Grafo no es mas que un conjunto de nodos o vértices que se encuentran relacionados con unas aristas. Además los vértices tienen un valor y en ocasiones las aristas también y se le conoce como el costo. Se asocia cada fila y cada columna a cada nodo del grafo, siendo los elementos de la matriz la relación entre los mismos, tomando los valores de 1 si existe la arista y 0 en caso contrario.
import java.util.Vector;
import javax.swing.*;
public class Principal extends JApplet{
PanelDibujo pd;
int max=0;
JTextField valor;
public void init(){
pd=new PanelDibujo();
add(pd);
JPanel pdatos=new JPanel();
JButton agregar=new JButton("Agregar Nodo");
agregar.addActionListener(new ActionListener(){
@Override
public void actionPerformed(ActionEvent e) {
if(max<10){
try{
Grafo gf=new Grafo(""+Integer.parseInt(valor.getText()));
pd.getVgrafos().add(gf);
pd.repaint();
repaint();
max++;
}catch(NumberFormatException ne){
JOptionPane.showMessageDialog(null, "Digite un numero valido");
}
}
}
});
valor=new JTextField(5);
pdatos.add(new JLabel("Valor Vertice" +
""));
pdatos.add(valor);
pdatos.add(agregar);
add(pdatos,BorderLayout.SOUTH);
}
} Los árboles con los que trabajaremos tienen otra característica importante: cada nodo sólo puede ser apuntado por otro nodo, es decir, cada nodo sólo tendrá un padre. Esto hace que estos árboles estén fuertemente jerarquizados, y es lo que en realidad les da la apariencia de árboles. /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package Cola;
import javax.swing.JOptionPane;
/**
*
* @author Manybadilla
*/
public class Cola {
Nodo front;
Nodo back;
public void enqueue(Persona persona) {
Nodo nuevo = new Nodo(persona);
if (isEmpty()) {
front = nuevo;
back = nuevo;
} else {
back.setTop(nuevo);
back = nuevo;
}
}
public Nodo getBack() {
return back;
}
public Nodo getFront() {
return front;
}
public void denqueue() {
if (isEmpty()) {
} else {
front = front.getTop();
}
}
public String printStack() {
Nodo actual = front;
String mensaje = "";
if (isEmpty()) {
return "Esta Vacia";
} else {
while (actual != null) {
mensaje += actual.getPersona().toString() + "\n";
actual = actual.getTop();
}
}
return mensaje;
}
public boolean isEmpty() {
if (front == null) {
return true;
} else {
return false;
}
}
} La cola es como cuando uno hace fila para entrar algun sitio los primeros son los que entran y los ultimos de la cola son los ultimos en entrar. public class Arbol {

// insertar(Raiz, Raiz, x)
public boolean arbolVacio(){return Raiz == null;}
public void insertar(Nodo ant, Nodo p, Nodo x){
if (p != null){
if (Integer.parseInt(x.getDato().toString()) > Integer.parseInt(p.getDato().toString())) {
insertar(p, p.getPd(), x);
}else{
insertar(p, p.getPi(), x);
}
}else{
if (arbolVacio()){
Raiz = x;
}else{
if (Integer.parseInt(x.getDato().toString()) > Integer.parseInt(ant.getDato().toString())) {
ant.setPd(x);
}else {
ant.setPi(x);
}
}
}
}
public void imprimir(Nodo p){
if(p != null){
imprimir(p.getPi());
System.out.print(p.getDato()+"; ");
imprimir(p.getPd());
}
}
public Nodo getRaiz() {
return Raiz;
}
public void setRaiz(Nodo raiz) {
Raiz = raiz;
}

}
}
}
public void eliminarNodoHoja(Nodo ant, Nodo p){
if (Raiz != p){
if(ant.getPd() == p){
ant.setPd(null);
}else{
ant.setPi(null);
}
}else{
Raiz = null;
}
}
public void eliminarNodoCon1SubArnol(Nodo ant,
}
}
}
}
Full transcript