Una de las formas más básicas de recorrer un grafo es el DFS (Depth First Search) que se traduce como Búsqueda en Profundidad; y básicamente  eso es lo que hace, dado un grafo, parte de un nodo inicial y lo recorre de la siguiente manera:

1. Visita el nodo inicial.
2. Visita su primer nodo adyacente (Nodo conectado a el).
3. Visita el primer nodo adyacente del nuevo nodo.
4. Repite el proceso hasta que ya no tenga mas nodos que visitar (llego a una hoja o el nodo que sigue ya esta visitado);
5. Cuando llega al paso anterior, se devuelve (Backtracking) hasta el primer lugar en el grafo donde queden nodos por visitar.

Una vez el DFS termina su recorrido, este grafo se convierte en un árbol.

El DFS  logra su recorrido con una pila, cada nodo nuevo que se valla visitando se va metiendo a la pila, cuando llega la hora de hacer el backtracking sacamos de la pila y repetimos el procedimiento. Por suerte la recursión hace todo este trabajo y nos evita el uso de la pila.

A continuación, mi pequeña implementación recursiva del DFS en C++.

void dfs(vector<int> * g, bool * visited, int start){

  //Acabamos de visitar un nodo, asi que lo tachamos
  visited[start] = true;
  cout << "Nodo " << start << " visitado" << endl;

  //Para Cada Nodo visitamos sus adyacentes
  //Osea a los que este puede ir
  for(int i = 0; i < g[start].size(); i++){

    //Si el nodo no ha sido visitado todavia
    //Le aplicamos nuevamente el mismo procedimiento
    if(!visited[g[start][i]]){
      dfs(g, visited, g[start][i]);
    }
  }

}

PD: Para que el DFS funcione correctamente el grafo debe ser conexo, es decir cada nodo debe estar conectado con otro, lo que significa que siempre debe haber un camino de un nodo a otro, cualquiera que sea.

Yo quiero una de estas

No me detendré a explicar a fondo los tipos de grafos y todo lo que esto implica, supondré que todo esto ya lo sabes o puedes leerlo de wikipedia.

Matrices

Esta es la forma mas directa de representar un árbol siendo la fila (Nodo fuente) y la columna (Nodo destino). Es decir si tenemos una matriz 4×3 lo siguiente: grafo[2][1] = 3; significa que de el nodo 2 al nodo 1 puedo ir y esa arista posee un valor de 3.

Las ventajas de trabajar con matrices son muchas entre las cuales se destacan, la rapidez y la flexibilidad que tienen, se puede acceder, modificar, borrar muy fácilmente; pero su problema es el espacio, es la estructura que más espacio ocupa.

Arreglos de Vectores

Esta forma es un poco mas específica para un grafo (lo representa más claramente), principalmente se tiene un arreglo de tamaño N, siendo N el numero de nodos del grafo y en cada espacio del arreglo se tiene un vector que almacenara los nodos que puede alcanzar el nodo especificado por el arreglo.

Las ventajas son: Conceptualmente más claro, rapido acceso, y modificación, el vector hace todo el trabajo de la memoria dinámica (lo cual puede ser un fastidio en lenguajes como C/C++).

Las desventajas son: Inserción un poco mas lenta, borrado algo engorroso (C++), se hace obligatorio el uso de estructuras cuando trabajamos con grafos con peso (weighted graphs).

Ahora un pequeño código escrito en C++ que ejemplifica estos 2 metodos de representar grafos.

#include <iostream>
#include <vector>
#include <list>
#include <cstring>

#define MAXN 100  //Maximun numbers of nodes

//Matrix
int graph1[MAXN][MAXN];

//Array Vector
vector graph2[MAXN];

void fillMatrix(){

  //Initializate(Fill it with 0's)
  memset(graph1, 0, sizeof(int));

  //Direct Asignation
  //(Valid path from Node 2 to Node 3 with weight 5)
  graph1[2][3] = 5;

  //Direct Access
  cout << graph1[2][3] << endl;

}

void fillVector(){

  //Slower Asignation, no weight.
  //For weight push_back a custome struct
  graph2[2].push_back(3);

  //Direct Access
  cout << graph2[2][0] << endl;

}

int main(){

  fillMatrix();
  fillVector();

  return 0;
}

Disculpen si me he saltado muchas cosas, pero no estoy acostumbrado a hacer tutoriales, espero aprender en el camino

La teoría es cuando crees saber algo, pero no funciona. La práctica es cuando algo funciona, pero no sabes por qué. Los programadores combinan la teoría y la práctica: Nada funciona y no saben por qué.

– Anónimo

Mundo Geek

Lo primero es crear la carpeta en donde queramos q se monte la imagen (*.iso):

Lo siguiente será crear un archivo con cualquier editor de texto y agregar el siguiente script; para el ejemplo el archivo se llamará IsoMount:

#! /bin/bash

sudo mount -o loop -t iso9660 $1 /media/iso

Ahora tenemos que darle permisos  de ejecución al script:

Lo ultimo es ponerlo donde debe estar:

Ya ahora podremos ejecutar el Script desde cualquier ubicación y la *.iso se montará en /media/iso

Como extra, para los usuarios de Nautilus y que le guste las cosas mas gráficas tambien podemos que el script se integre con este mas al estilo Windows, solo tenemos que crear un nuevo script de igual manera que el anterior pero con esta pequeña modificación. No olvidar darle también permisos de ejecución (El nuevo Archivo se llamará “Mount”):

#! /bin/bash

gksu imount $NAUTILUS_SCRIPT_SELECTED_FILE_PATHS

#Comentario para que se noten los subguiones del comando anterior.

Lo último es copiar este script a la siguiente carpeta:

Ya no es mas que darle click derecho al *.iso y darle a Scripts > Mount

Saludos!

Si alguien necesita deje su e-mail en los comentarios

PD: Recuerden que google toma su tiempo para mandar las invitaciones, asi que no se desesperen.

Aquí les dejo un sencillo ejemplo sobre como utilizar Threads en C#…. así o mas fácil!

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace Thread_Sample
{
    class Program
    {
        private Thread th1;
        private Thread th2;
        private int numero = 0;

        Program()
        {
            th1 = new Thread(new ParameterizedThreadStart(contador));
            th2 = new Thread(new ParameterizedThreadStart(contador));
        }

        public void run()
        {
            for (int i = 0; i < 2; i++)
            {
                if (i == 0)
                {
                    th1.Start(0);
                }
                else
                {
                    th2.Start(1);
                }
            }

            //Whait for the threads to live (start)
            while (!th1.IsAlive && !th2.IsAlive);

            //Wait for the threads to die (end)
            while (th1.IsAlive && th2.IsAlive);
        }

        public void contador(object obj)
        {
            int i = (int)(obj);
            for (int j = 0; j < 50; j++)
            {
                if (i == 0)
                {
                    numero++;
                    Console.WriteLine("Thread 0: " + numero);
                    Thread.Sleep(100);          //For you to see the procces
                }
                else
                {
                    numero++;
                    Console.WriteLine("Thread 1: " + numero);
                    Thread.Sleep(100);          //For you to see the procces
                }
            }
        }

        static void Main(string[] args)
        {

            Program p = new Program();
            p.run();

            Console.WriteLine("Ya termino el programa");
            Console.Read();
        }
    }
}

Via: Linux Hispano