Data Structures and C/C++ Graphs basics

#include <iostream>
#define size 5
using namespace std;

int main(int argc, char *argv[])
{
  // declare an array of 5 integers
  int array[size] = {1, 2, 3, 4, 5};
  // declare pointer that points to an integer data type
  int *p;

  for (int i = 0; i < size; ++i)
    cout << array[i] << " ";
  cout << endl;


  // point to the above array
  // this can be done, because an array is a data structure
  // that reserves contiguous memory on the process/program timeline execution.
  p = array;


  for (int i = 0; i < size; ++i)
    cout << "value:" << p[i] << " memory address: " << &p[i] << endl;

  // same output . different way
  for (int i = 0; i < size; ++i)
    cout << "value:" << (*(p + i)) << " memory address: " << (p + i) << endl;

  // now lets change the value of an integer getting its reference and modifying the value
  int valuex = 10;
  cout << "valuex before: " << valuex << endl;
  int* xptr = &valuex; // the amperson indicates: "give me the memory adress of this variable"
  *xptr = 7;
  cout << "valuex after: " << valuex << endl;

  // Notes:
  // all the pointers occupy the same amount of memory.
  // the size of the pointer will depend on the system architecture target compile.
  // we can point to any existing type of data, that includes "structs".
  // pointers are used everywhere, in all programming languages, implicitly or explicitly but everywhere.

  return 0;
}

#include <iostream>

struct Book {
  float price;
  char name[50];
};

int main(int argc, char *argv[])
{
  Book bookx;
  // set up some random values
  strcpy(bookx.name, "C Programming");
  bookx.price = 77;

  // declare a pointer to an struct
  struct Book * bookPtr;
  bookPtr = &bookx;

  std::cout << "Book Name: " << bookPtr->name <<
    " Book price($dlls): " << bookPtr->price << std::endl;

  // changing the value by reference
  strcpy(bookPtr->name, "C++ Programming");
  bookPtr->price = 87;

  std::cout << "Book Name: " << bookPtr->name <<
    " Book price($dlls): " << bookPtr->price << std::endl;
  return 0;
}

#include<stdlib.h>
#include<stdio.h>

int main(int argc, char *argv[])
{

  // allocating memory using malloc helper function
  int* array = malloc(sizeof(int) * 5);
  array[0] = 7;
  printf("%d", array[0]);

  // Note: be aware that in C and C++ always you do memory allocation
  // you must free or release it when you finish to use it,
  // otherwise you can have memory leak problems.
  // In C we use the free function to release the allocated memory.
  // In C++ we use the delete keyword. (Look at the next c++ example snippet)
  free(array);
  return 0;
}

#include <iostream>
#include <ostream>

int main(int argc, char *argv[])
{

  int *array = new int[5];
  array[0] = 7;

  std::cout << array[0] << std::endl;
  // Notes:
  // instead of using malloc function as in C, we can use the 'new' keyword.

  // here we use the 'delete' keyword followed by the brackets to indicate that
  // we cant to release the allocated memory.

  delete [] array;
  return 0;
}

#include "stdio.h"
#include "queue"
#include "stdlib.h"
#define N 8

using namespace std;

void bfs(int firstElement);

int main(int argc, char *argv[])
{
  printf("%s\n", "bfs with node: ");
  for (int i = 1; i < N; ++i) {
    printf("%d -> ", i);
    bfs(i);
    printf("\n");
  }

  return 0;
}

void bfs(int firstElement) {

  int * visited = (int *) malloc(sizeof(int) * N);
  queue<int> q;

  // initialize visited array
  for (int i = 0; i < N; i++)
    visited[i] = 0;

  // visit 
  printf("%d ", firstElement);

  // mark as visited
  visited[firstElement] = 1;
  // push to the queue
  q.push(firstElement);

  // repeat above process
  while (!q.empty()) {
    int r = q.front(); q.pop();

    for (int c = 1; c < N; c++)
      if (gam[r][c] == 1 && visited[c] == 0) {
        printf("%d ", c);
        q.push(c);
        visited[c] = 1;
      }
  }

  free(visited);
}

// Note: gam is the graph-adjacent-matrix
// the variable is loaded from the table displayed above

#include <cstdio>
#include<stdio.h>
#include "stdlib.h"
#include "stack"
#define N 8

void dfs(int firstNode);
void recursive_dfs(int firstNode);
int *visited_nodes = (int *)malloc(sizeof(int) * N);
void clear_visited_nodes_array(void);

int main(int argc, char *argv[])
{

  // initialize global array
  for (int i = 0; i < N; ++i)
    visited_nodes[i] = 0;

  for (int i = 1; i < N; ++i) {
    printf("dfs for node:  %d -> ", i);
    recursive_dfs(i);
    printf("\n");
    clear_visited_nodes_array();
  }

  return 0;
}

void clear_visited_nodes_array() {
  for (int i = 0; i < N; ++i)
    visited_nodes[i] = 0;
}

void dfs(int firstElement) {
  // visit
  // explore
  int * visited = (int *) malloc(sizeof(int) * N);
  for (int i = 0; i < N; ++i)
    visited[i] = 0;

  std::stack<int> stack;

  // exploring
  stack.push(firstElement);

  while (!stack.empty()) {
    int e = stack.top(); stack.pop();

    if (visited[e])
      continue;

    printf("%d ", e);
    visited[e] = 1;
    for (int c = 1; c < N; c++)
      if (gam[e][c] == 1)
        stack.push(c);
  }
}

void recursive_dfs(int node) {
  if (visited_nodes[node] == 0) {
    printf("%d ", node);
    visited_nodes[node] = 1;
    for (int i = 1; i < N; ++i)
      if (gam[node][i] == 1 && visited_nodes[i] == 0) 
        recursive_dfs(i);
  }
}