Trabajando

En C+ o Java, crear las funciones para eliminar vértices (eliminar un nodo en una lista ligada) y eliminar aristas

Publicado el 08 Junio, 2019 en Programación y Tecnología

Sobre este proyecto

Menos de USD 10 / hora

Utilizando el ejemplo muestra hecho en C++ o Java, crear las funciones para eliminar vértices (eliminar un nodo en una lista ligada) y eliminar aristas (el mismo caso).

#Include <iostream>
#include <cstdlib>        //librerias necesarias para que las instruccuiones sean reconocidas por el compilador

using namespace std;

struct nodo    //estructura del vertice y arista
{
  int dato;                                              // cuando es un vertice guarda un dato pero si es una arista guara el peso
  struct nodo *liga_vertice;        //guardan las direcciones de los siguientes nodos o vertices y aristas
  struct nodo *liga_arista;
};


typedef struct nodo *registro;
registro sig_ver, ant_ver, cab_ver,sig_ari, ant_ari,dir1,dir2;  //apuntadores de memoria


registro nuevo_vertice(int dat)  //a�ade un nuevo vertice
{
    registro reg_ver = new(struct nodo);  //instruccion para pedir memoria con la estructura del vertice o nodo
    reg_ver->dato = dat;
    reg_ver->liga_vertice=null;
    reg_ver->liga_arista= null;
    return reg_ver;
}


void insertarvertice(int dat)    //funcion para insertar un nuevo vertice
{
    int sw;
        sw=0;
    ant_ver=cab_ver;
    sig_ver=cab_ver;
      while (sig_ver != null && sw==0)  //recorre el grafo verificando si el vertive existe, sino existe lo adiciona al final
      {                                                              //si existe saca u mensaje de error
    if (sig_ver->dato==dat) 
          {
                sw=1;
      }
          else
        {
                ant_ver=sig_ver;   
                      sig_ver=sig_ver->liga_vertice;
        }
    }
    if (sw==1)
      {
              cout << "\n vertice ya existe no se adiciona\n";
      }
      else
    {
            if (cab_ver==null)
            {
                    cab_ver=nuevo_vertice(dat); //el primer vertice queda como cabeza
        }
        else
              {
                      ant_ver->liga_vertice=nuevo_vertice(dat); //se adiciona despues del ultimo vertice
        }
        cout << "vertice adicionado \n";
  } 
}


registro recorrer_vertice(int dat)
{
  registro dir;
dir=null;
sig_ver=cab_ver;
  while (sig_ver != null)  //recorre el grafo buscando uno en especial
    {                                   
            if (sig_ver->dato==dat) 
          {
                    dir=sig_ver;
        }
      sig_ver=sig_ver->liga_vertice;
      }
      return dir;
}     


registro nueva_arista(int pes)  //a�ade una nueva arista al vertice
{
    registro reg_ari = new(struct nodo);  //instruccion para pedir memoria con la estructura de las aristas
    reg_ari->dato = pes;
    reg_ari->liga_arista=null;
    reg_ari->liga_vertice=dir2;
    return reg_ari;
}

   
void insertararista(int dato_destino)  //funcion para insertar una nueva arista
{
      int sw2,pes;
    sw2=0;
    ant_ari=dir1;
    sig_ari=dir1;
        while (sig_ari != null && sw2==0)  //recorre la sublista de aristas de ese vertice
  {
      if (sig_ari->dato==dato_destino) 
          {
                sw2=1;
    }
        else
      {
                      ant_ari=sig_ari; 
                  sig_ari=sig_ari->liga_arista;
        }
    }
    if (sw2==1)    //si la arista existe no se adiciona
      {
              cout<<"arista ya existe no se adiciona \n\n ";
}
else
      {
              cout<< "digite el peso de la arista: ";
              cin >> (pes);
              ant_ari->liga_arista=nueva_arista(pes);
        }
}


void verlista()
{
cout<< "\n\n ver lista de vertices y sus aristas";
        sig_ver=cab_ver;
while (sig_ver != null)  //busca los vertices
  {
          cout << "\n el nodo  ";
          cout<< (sig_ver->dato );
        cout << " tiene las siguientes aristas  ";
        sig_ari=sig_ver->liga_arista; //pasa al siguiente vertice o nodo
      while (sig_ari != null)  //busca las aristas
            {   
                  cout << " ";
              dir1=sig_ari->liga_vertice;
        cout<< dir1->dato;
                    sig_ari=sig_ari->liga_arista; //pasa a la siguiente arista
          }
            sig_ver=sig_ver->liga_vertice;
    }
}

int main()  //programa principal
{
cab_ver = null;    //grafo vacio
    int dato_origen,dato_destino;
    int sw,opc=10;
    char resp;
   
    while (opc != 4)
    {
        cout << "\n grafo con vertices (nodos) y las aristas que los unen \n";
      cout << "\n 1. Creacion de vertices";
              cout << "\n 2. Creacion de aristas";
        cout << "\n 3.


Mostrar grafo";
      cout << "\n 4. SALIR";
          cout << "\n SELECCIONE OPCION ENTRE 1 y 4 ";
          cin>>(opc);
          switch (opc)
          {
                  case 1: Resp='s';
                                while (Resp =='s')          //a�ade vertices hsta que diga que NO (n)
                                    {
                                        cout << "Digite dato para vertice (dato numerico): ";  //se pide cual es el vertice origen
                                            cin >> dato_origen;
                                      insertarVertice(dato_origen);  //se llama el metodo insertarVertice (para a�adir un nuevo nodo o vertice)
                                    cout <<"\n Desea continuar insertando vertices s/n?: ";
                                      cin >>Resp;
                                  }
                              break;
                 
          case 2: Resp='s';
                            while (Resp =='s')          //a�ade aristas hsta que diga que NO (n)
                                  {
                                        cout << "Digite dato nodo origen (dato numerico): ";
                                      cin >> dato_origen;
                                          cout << "Digite dato nodo destino (dato numerico): ";
                                      cin >> dato_destino;
                                        dir1=recorrer_vertice(dato_origen);
                                        dir2=recorrer_vertice(dato_destino);
                                      if (dir1==NULL || dir2==NULL)
                                        {
                                                  cout <<"\n Nodo origen o destino no existen revise";
                                          }
                                          else
                                        {
                                                  insertarArista(dato_destino);  //se llama el metodo insertarVertice (para a�adir un nuevo nodo o vertice)
                                    }
                                      cout <<"\n Desea continuar insertando vertices s/n?: ";
                                    cin >>Resp;
                                }
                                  break;
                             
                case 3: verlista();
                                cout << endl << endl;
                                  system("pause");  //genera una pausa para ver los datos
                            break;
    } 
  }
  return 0;
}

Categoría Programación y Tecnología
Subcategoría Aplicaciones de escritorio
¿Cuál es el alcance del proyecto? Bug o cambio pequeño
¿Es un proyecto o una posición? Un proyecto
Actualmente tengo Tengo las especificaciones
Disponibilidad requerida Según se necesite
Experiencia en este tipo de proyectos No (No he administrado este tipo de proyectos anteriormente)
Integraciones de API Otros (Otras APIs)
Plataformas requeridas Windows

Duración del proyecto: 1 - 4 semanas

Habilidades necesarias

C

¿Te gustaría comenzar a trabajar en este proyecto?

Ingresa con tu cuenta de Workana o Regístrate. ¡Potencia tu trabajo freelance!