dcsimg
CodeGuru Home VC++ / MFC / C++ .NET / C# Visual Basic VB Forums Developer.com
Results 1 to 3 of 3

Thread: convert c++ to java

  1. #1
    Join Date
    Nov 2019
    Posts
    1

    Lightbulb convert c++ to java

    Code:
    #include <stdio.h>
    #include <stdlib.h>
    #include <limits.h>
    #include<stdbool.h>
    
    // // A structure to represent a node in adjacency list
    struct AdjListNode
    {
      int dest;
      int weight;
      struct AdjListNode *next;
    };
    
    // A structure to represent an adjacency liat
    struct AdjList
    {
      struct AdjListNode *head;	// pointer to head node of list
    };
    
    // A structure to represent a graph. A graph is an array of adjacency lists.
    // Size of array will be V (number of vertices in graph)
    struct Graph
    {
      int V;
      struct AdjList *array;
    };
    
    // A utility function to create a new adjacency list node
    struct AdjListNode *
    newAdjListNode (int dest, int weight)
    {
      struct AdjListNode *newNode =
        (struct AdjListNode *) malloc (sizeof (struct AdjListNode));
      newNode->dest = dest;
      newNode->weight = weight;
      newNode->next = NULL;
      return newNode;
    }
    
    // A utility function that creates a graph of V vertices
    struct Graph *
    createGraph (int V)
    {
      struct Graph *graph = (struct Graph *) malloc (sizeof (struct Graph));
      graph->V = V;
    
      // Create an array of adjacency lists. Size of array will be V
      graph->array = (struct AdjList *) malloc (V * sizeof (struct AdjList));
    
      // Initialize each adjacency list as empty by making head as NULL
      for (int i = 0; i < V; ++i)
        graph->array[i].head = NULL;
    
      return graph;
    }
    
    // Adds an edge to an undirected graph
    void
    addEdge (struct Graph *graph, int src, int dest, int weight)
    {
      // Add an edge from src to dest. A new node is added to the adjacency
      // list of src. The node is added at the begining
      struct AdjListNode *newNode = newAdjListNode (dest, weight);
      newNode->next = graph->array[src].head;
      graph->array[src].head = newNode;
    
      // Since graph is undirected, add an edge from dest to src also
      newNode = newAdjListNode (src, weight);
      newNode->next = graph->array[dest].head;
      graph->array[dest].head = newNode;
    }
    
    // Structure to represent a min heap node
    struct MinHeapNode
    {
      int v;
      int dist;
    };
    
    // Structure to represent a min heap
    struct MinHeap
    {
      int size;			// Number of heap nodes present currently
      int capacity;			// Capacity of min heap
      int *pos;			// This is needed for decreaseKey()
      struct MinHeapNode **array;
    };
    
    // A utility function to create a new Min Heap Node
    struct MinHeapNode *
    newMinHeapNode (int v, int dist)
    {
      struct MinHeapNode *minHeapNode =
        (struct MinHeapNode *) malloc (sizeof (struct MinHeapNode));
      minHeapNode->v = v;
      minHeapNode->dist = dist;
      return minHeapNode;
    }
    
    // A utility function to create a Min Heap
    struct MinHeap *
    createMinHeap (int capacity)
    {
      struct MinHeap *minHeap =
        (struct MinHeap *) malloc (sizeof (struct MinHeap));
      minHeap->pos = (int *) malloc (capacity * sizeof (int));
      minHeap->size = 0;
      minHeap->capacity = capacity;
      minHeap->array =
        (struct MinHeapNode **) malloc (capacity * sizeof (struct MinHeapNode *));
      return minHeap;
    }
    
    // A utility function to swap two nodes of min heap. Needed for min heapify
    void
    swapMinHeapNode (struct MinHeapNode **a, struct MinHeapNode **b)
    {
      struct MinHeapNode *t = *a;
      *a = *b;
      *b = t;
    }
    
    // A standard function to heapify at given idx
    // This function also updates position of nodes when they are swapped.
    // Position is needed for decreaseKey()
    void
    minHeapify (struct MinHeap *minHeap, int idx)
    {
      int smallest, left, right;
      smallest = idx;
      left = 2 * idx + 1;
      right = 2 * idx + 2;
    
      if (left < minHeap->size &&
          minHeap->array[left]->dist < minHeap->array[smallest]->dist)
        smallest = left;
    
      if (right < minHeap->size &&
          minHeap->array[right]->dist < minHeap->array[smallest]->dist)
        smallest = right;
    
      if (smallest != idx)
        {
          // The nodes to be swapped in min heap
          struct MinHeapNode *smallestNode = minHeap->array[smallest];
          struct MinHeapNode *idxNode = minHeap->array[idx];
    
          // Swap positions
          minHeap->pos[smallestNode->v] = idx;
          minHeap->pos[idxNode->v] = smallest;
    
          // Swap nodes
          swapMinHeapNode (&minHeap->array[smallest], &minHeap->array[idx]);
    
          minHeapify (minHeap, smallest);
        }
    }
    
    // A utility function to check if the given minHeap is ampty or not
    int
    isEmpty (struct MinHeap *minHeap)
    {
      return minHeap->size == 0;
    }
    
    // Standard function to extract minimum node from heap
    struct MinHeapNode *
    extractMin (struct MinHeap *minHeap)
    {
      if (isEmpty (minHeap))
        return NULL;
    
      // Store the root node
      struct MinHeapNode *root = minHeap->array[0];
    
      // Replace root node with last node
      struct MinHeapNode *lastNode = minHeap->array[minHeap->size - 1];
      minHeap->array[0] = lastNode;
    
      // Update position of last node
      minHeap->pos[root->v] = minHeap->size - 1;
      minHeap->pos[lastNode->v] = 0;
    
      // Reduce heap size and heapify root
      --minHeap->size;
      minHeapify (minHeap, 0);
    
      return root;
    }
    
    // Function to decreasy dist value of a given vertex v. This function
    // uses pos[] of min heap to get the current index of node in min heap
    void
    decreaseKey (struct MinHeap *minHeap, int v, int dist)
    {
      // Get the index of v in heap array
      int i = minHeap->pos[v];
    
      // Get the node and update its dist value
      minHeap->array[i]->dist = dist;
    
      // Travel up while the complete tree is not hepified.
      // This is a O(Logn) loop
      while (i && minHeap->array[i]->dist < minHeap->array[(i - 1) / 2]->dist)
        {
          // Swap this node with its parent
          minHeap->pos[minHeap->array[i]->v] = (i - 1) / 2;
          minHeap->pos[minHeap->array[(i - 1) / 2]->v] = i;
          swapMinHeapNode (&minHeap->array[i], &minHeap->array[(i - 1) / 2]);
    
          // move to parent index
          i = (i - 1) / 2;
        }
    }
    
    // A utility function to check if a given vertex
    // 'v' is in min heap or not
    bool
    isInMinHeap (struct MinHeap *minHeap, int v)
    {
      if (minHeap->pos[v] < minHeap->size)
        return true;
      return false;
    }
    
    // A utility function used to print the solution
    void
    printArr (int dist[], int n)
    {
      printf ("Vertex   Distance from Source\n");
      for (int i = 0; i < n; ++i)
        printf ("%d \t\t %d\n", i, dist[i]);
    }
    
    // The main function that calulates distances of shortest paths from src to all
    // vertices. It is a O(ELogV) function
    void
    dijkstra (struct Graph *graph, int src)
    {
      int V = graph->V;		// Get the number of vertices in graph
      int dist[V];			// dist values used to pick minimum weight edge in cut
    
      // minHeap represents set E
      struct MinHeap *minHeap = createMinHeap (V);
    
      // Initialize min heap with all vertices. dist value of all vertices
      for (int v = 0; v < V; ++v)
        {
          dist[v] = INT_MAX;
          minHeap->array[v] = newMinHeapNode (v, dist[v]);
          minHeap->pos[v] = v;
        }
    
      // Make dist value of src vertex as 0 so that it is extracted first
      minHeap->array[src] = newMinHeapNode (src, dist[src]);
      minHeap->pos[src] = src;
      dist[src] = 0;
      decreaseKey (minHeap, src, dist[src]);
    
      // Initially size of min heap is equal to V
      minHeap->size = V;
    
      // In the followin loop, min heap contains all nodes
      // whose shortest distance is not yet finalized.
      while (!isEmpty (minHeap))
        {
          // Extract the vertex with minimum distance value
          struct MinHeapNode *minHeapNode = extractMin (minHeap);
          int u = minHeapNode->v;	// Store the extracted vertex number
    
          // Traverse through all adjacent vertices of u (the extracted
          // vertex) and update their distance values
          struct AdjListNode *pCrawl = graph->array[u].head;
          while (pCrawl != NULL)
    	{
    	  int v = pCrawl->dest;
    
    	  // If shortest distance to v is not finalized yet, and distance to v
    	  // through u is less than its previously calculated distance
    	  if (isInMinHeap (minHeap, v) && dist[u] != INT_MAX &&
    	      pCrawl->weight + dist[u] < dist[v])
    	    {
    	      dist[v] = dist[u] + pCrawl->weight;
    
    	      // update distance value in min heap also
    	      decreaseKey (minHeap, v, dist[v]);
    	    }
    	  pCrawl = pCrawl->next;
    	}
        }
    
      // print the calculated shortest distances
      printArr (dist, V);
    }
    
    
    // Driver program to test above functions
    int
    main ()
    {
      // create the graph given in above fugure
      int V = 9;
      struct Graph *graph = createGraph (V);
      addEdge (graph, 0, 1, 4);
      addEdge (graph, 0, 7, 8);
      addEdge (graph, 1, 2, 8);
      addEdge (graph, 1, 7, 11);
      addEdge (graph, 2, 3, 7);
      addEdge (graph, 2, 8, 2);
      addEdge (graph, 2, 5, 4);
      addEdge (graph, 3, 4, 9);
      addEdge (graph, 3, 5, 14);
      addEdge (graph, 4, 5, 10);
      addEdge (graph, 5, 6, 2);
      addEdge (graph, 6, 7, 1);
      addEdge (graph, 6, 8, 6);
      addEdge (graph, 7, 8, 7);
    
      dijkstra (graph, 0);
    
      return 0;
    }
    Last edited by Arjay; November 23rd, 2019 at 10:56 AM. Reason: Added code tags

  2. #2
    Arjay's Avatar
    Arjay is offline Moderator / EX MS MVP Power Poster
    Join Date
    Aug 2004
    Posts
    13,173

    Re: convert c++ to java

    Please use code tags. Since you haven't asked a question, I would imagine that you might be looking for someone to write the code for you, but it is unlikely this will happen. However, if you start trying to convert the code yourself and run into specific issues, post back and we will attempt to help.

  3. #3
    Join Date
    Nov 2018
    Posts
    23

    Re: convert c++ to java

    Seems like jango is back with a new alias.
    http://forums.codeguru.com/showthrea...ssignment-Help

    No doubt the result of some google search and bugger all effort except to dump it here.
    Oh, and just to be pedantic - you posted C code, not C++ code.


    Here's another one for you.
    https://www.google.com/search?q=%2F%...re+int+V+%3D+9

    Silly typos in the code make it dead easy to search for.
    There are numerous derived examples of some basic butchered code to choose from.

Tags for this Thread

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  


Windows Mobile Development Center


Click Here to Expand Forum to Full Width




On-Demand Webinars (sponsored)