#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct
{
void* pElements;
size_t ElementSize;
size_t Count; // how many elements exist
size_t TotalCount; // for how many elements space allocated
} tArray;
void ArrayInit(tArray* pArray, size_t ElementSize)
{
pArray->pElements = NULL;
pArray->ElementSize = ElementSize;
pArray->TotalCount = pArray->Count = 0;
}
void ArrayDestroy(tArray* pArray)
{
ArrayInit(pArray, 0);
}
int ArrayGrowByOne(tArray* pArray)
{
if (pArray->Count == pArray->TotalCount) // used up all allocated space
{
size_t newTotalCount, newTotalSize;
void* p;
if (pArray->TotalCount == 0)
{
newTotalCount = 1;
}
else
{
newTotalCount = 2 * pArray->TotalCount; // double the allocated count
if (newTotalCount / 2 != pArray->TotalCount) // count overflow
return 0;
}
newTotalSize = newTotalCount * pArray->ElementSize;
if (newTotalSize / pArray->ElementSize != newTotalCount) // size overflow
return 0;
p
= realloc(pArray
->pElements
, newTotalSize
); if (p == NULL) // out of memory
return 0;
pArray->pElements = p;
pArray->TotalCount = newTotalCount;
}
pArray->Count++;
return 1;
}
int ArrayInsertElement(tArray* pArray, size_t pos, void* pElement)
{
if (pos > pArray->Count) // bad position
return 0;
if (!ArrayGrowByOne(pArray)) // couldn't grow
return 0;
if (pos < pArray->Count - 1)
memmove((char*)pArray
->pElements
+ (pos
+ 1) * pArray
->ElementSize
, (char*)pArray->pElements + pos * pArray->ElementSize,
(pArray->Count - 1 - pos) * pArray->ElementSize);
memcpy((char*)pArray
->pElements
+ pos
* pArray
->ElementSize
, pElement,
pArray->ElementSize);
return 1;
}
typedef struct
{
int Id;
int Data;
tArray LinksTo; // links from this node to other nodes (array of Id's)
tArray LinksFrom; // back links from other nodes to this node (array of Id's)
} tNode;
typedef struct
{
tArray Nodes;
} tGraph;
void GraphInit(tGraph* pGraph)
{
ArrayInit(&pGraph->Nodes, sizeof(tNode));
}
void GraphPrintNodes(tGraph* pGraph)
{
size_t i, j;
if (pGraph->Nodes.Count == 0)
{
}
for (i = 0; i < pGraph->Nodes.Count; i++)
{
tNode* pNode = (tNode*)pGraph->Nodes.pElements + i;
printf("Node %d:\n Data: %d\n", pNode
->Id
, pNode
->Data
);
if (pNode->LinksTo.Count)
{
for (j = 0; j < pNode->LinksTo.Count; j++)
{
int* p = (int*)pNode->LinksTo.pElements + j;
}
}
}
}
void GraphDestroy(tGraph* pGraph)
{
size_t i;
for (i = 0; i < pGraph->Nodes.Count; i++)
{
tNode* pNode = (tNode*)pGraph->Nodes.pElements + i;
ArrayDestroy(&pNode->LinksTo);
ArrayDestroy(&pNode->LinksFrom);
}
ArrayDestroy(&pGraph->Nodes);
}
int NodeIdComparator(const void* p1, const void* p2)
{
const tNode* pa = p1;
const tNode* pb = p2;
if (pa->Id < pb->Id)
return -1;
if (pa->Id > pb->Id)
return 1;
return 0;
}
int IntComparator(const void* p1, const void* p2)
{
const int* pa = p1;
const int* pb = p2;
if (*pa < *pb)
return -1;
if (*pa > *pb)
return 1;
return 0;
}
size_t GraphFindNodeIndexById(tGraph* pGraph, int Id)
{
pGraph->Nodes.pElements,
pGraph->Nodes.Count,
pGraph->Nodes.ElementSize,
&NodeIdComparator);
if (pNode == NULL)
return (size_t)-1;
return pNode - (tNode*)pGraph->Nodes.pElements;
}
int GraphInsertNode(tGraph* pGraph, int Id, int Data)
{
size_t idx = GraphFindNodeIndexById(pGraph, Id);
tNode node;
if (idx != (size_t)-1) // node with this Id already exist
return 0;
node.Id = Id;
node.Data = Data;
ArrayInit(&node.LinksTo, sizeof(int));
ArrayInit(&node.LinksFrom, sizeof(int));
if (!ArrayInsertElement(&pGraph->Nodes, pGraph->Nodes.Count, &node))
return 0;
qsort(pGraph
->Nodes.
pElements, pGraph->Nodes.Count,
pGraph->Nodes.ElementSize,
&NodeIdComparator); // maintain order for binary search
return 1;
}
int GraphLinkNodes(tGraph* pGraph, int IdFrom, int IdTo)
{
size_t idxFrom = GraphFindNodeIndexById(pGraph, IdFrom);
size_t idxTo = GraphFindNodeIndexById(pGraph, IdTo);
tNode *pFrom, *pTo;
if (idxFrom == (size_t)-1 || idxTo == (size_t)-1) // one or both nodes don't exist
return 0;
pFrom = (tNode*)pGraph->Nodes.pElements + idxFrom;
pTo = (tNode*)pGraph->Nodes.pElements + idxTo;
// link IdFrom -> IdTo
pFrom->LinksTo.pElements,
pFrom->LinksTo.Count,
pFrom->LinksTo.ElementSize,
&IntComparator) == NULL) // IdFrom doesn't link to IdTo yet
{
if (!ArrayInsertElement(&pFrom->LinksTo, pFrom->LinksTo.Count, &IdTo))
return 0;
qsort(pFrom
->LinksTo.
pElements, pFrom->LinksTo.Count,
pFrom->LinksTo.ElementSize,
&IntComparator); // maintain order for binary search
}
// back link IdFrom <- IdTo
pTo->LinksFrom.pElements,
pTo->LinksFrom.Count,
pTo->LinksFrom.ElementSize,
&IntComparator) == NULL) // IdFrom doesn't link to IdTo yet
{
if (!ArrayInsertElement(&pTo->LinksFrom, pTo->LinksFrom.Count, &IdFrom))
return 0;
qsort(pTo
->LinksFrom.
pElements, pTo->LinksFrom.Count,
pTo->LinksFrom.ElementSize,
&IntComparator); // maintain order for binary search
}
return 1;
}
int main(void)
{
tGraph g;
printf("\nCreating empty graph...\n"); GraphInit(&g);
GraphPrintNodes(&g);
printf("\nInserting nodes...\n"); GraphInsertNode(&g, 0, 0);
GraphInsertNode(&g, 1, 101);
GraphInsertNode(&g, 2, 202);
GraphPrintNodes(&g);
printf("\nLinking nodes...\n"); GraphLinkNodes(&g, 0, 1);
GraphLinkNodes(&g, 0, 2);
GraphLinkNodes(&g, 1, 2);
GraphLinkNodes(&g, 2, 1);
GraphPrintNodes(&g);
printf("\nDestroying graph...\n"); GraphDestroy(&g);
GraphPrintNodes(&g);
// repeat
printf("\nLet's repeat...\n");
printf("\nCreating empty graph...\n"); GraphInit(&g);
GraphPrintNodes(&g);
printf("\nInserting nodes...\n"); GraphInsertNode(&g, 1, 111);
GraphInsertNode(&g, 2, 222);
GraphInsertNode(&g, 3, 333);
GraphPrintNodes(&g);
printf("\nLinking nodes...\n"); GraphLinkNodes(&g, 1, 2);
GraphLinkNodes(&g, 2, 3);
GraphLinkNodes(&g, 3, 1);
GraphPrintNodes(&g);
printf("\nDestroying graph...\n"); GraphDestroy(&g);
GraphPrintNodes(&g);
return 0;
}
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct
{
  void* pElements;
  size_t ElementSize;
  size_t Count; // how many elements exist
  size_t TotalCount; // for how many elements space allocated
} tArray;

void ArrayInit(tArray* pArray, size_t ElementSize)
{
  pArray->pElements = NULL;
  pArray->ElementSize = ElementSize;
  pArray->TotalCount = pArray->Count = 0;
}

void ArrayDestroy(tArray* pArray)
{
  free(pArray->pElements);
  ArrayInit(pArray, 0);
}

int ArrayGrowByOne(tArray* pArray)
{
  if (pArray->Count == pArray->TotalCount) // used up all allocated space
  {
    size_t newTotalCount, newTotalSize;
    void* p;

    if (pArray->TotalCount == 0)
    {
      newTotalCount = 1;
    }
    else
    {
      newTotalCount = 2 * pArray->TotalCount; // double the allocated count
      if (newTotalCount / 2 != pArray->TotalCount) // count overflow
        return 0;
    }

    newTotalSize = newTotalCount * pArray->ElementSize;
    if (newTotalSize / pArray->ElementSize != newTotalCount) // size overflow
      return 0;

    p = realloc(pArray->pElements, newTotalSize);
    if (p == NULL) // out of memory
      return 0;

    pArray->pElements = p;
    pArray->TotalCount = newTotalCount;
  }

  pArray->Count++;
  return 1;
}

int ArrayInsertElement(tArray* pArray, size_t pos, void* pElement)
{
  if (pos > pArray->Count) // bad position
    return 0;

  if (!ArrayGrowByOne(pArray)) // couldn't grow
    return 0;

  if (pos < pArray->Count - 1)
    memmove((char*)pArray->pElements + (pos + 1) * pArray->ElementSize,
           (char*)pArray->pElements + pos * pArray->ElementSize,
           (pArray->Count - 1 - pos) * pArray->ElementSize);

  memcpy((char*)pArray->pElements + pos * pArray->ElementSize,
         pElement,
         pArray->ElementSize);

  return 1;
}

typedef struct
{
  int Id;

  int Data;

  tArray LinksTo; // links from this node to other nodes (array of Id's)
  tArray LinksFrom; // back links from other nodes to this node (array of Id's)
} tNode;

typedef struct
{
  tArray Nodes;
} tGraph;

void GraphInit(tGraph* pGraph)
{
  ArrayInit(&pGraph->Nodes, sizeof(tNode));
}

void GraphPrintNodes(tGraph* pGraph)
{
  size_t i, j;

  if (pGraph->Nodes.Count == 0)
  {
    printf("Empty graph.\n");
  }

  for (i = 0; i < pGraph->Nodes.Count; i++)
  {
    tNode* pNode = (tNode*)pGraph->Nodes.pElements + i;

    printf("Node %d:\n  Data: %d\n", pNode->Id, pNode->Data);

    if (pNode->LinksTo.Count)
    {
      printf("  Links to:\n");

      for (j = 0; j < pNode->LinksTo.Count; j++)
      {
        int* p = (int*)pNode->LinksTo.pElements + j;
        printf("    Node %d\n", *p);
      }
    }
  }
}

void GraphDestroy(tGraph* pGraph)
{
  size_t i;

  for (i = 0; i < pGraph->Nodes.Count; i++)
  {
    tNode* pNode = (tNode*)pGraph->Nodes.pElements + i;
    ArrayDestroy(&pNode->LinksTo);
    ArrayDestroy(&pNode->LinksFrom);
  }

  ArrayDestroy(&pGraph->Nodes);
}

int NodeIdComparator(const void* p1, const void* p2)
{
  const tNode* pa = p1;
  const tNode* pb = p2;

  if (pa->Id < pb->Id)
    return -1;
  if (pa->Id > pb->Id)
    return 1;
  return 0;
}

int IntComparator(const void* p1, const void* p2)
{
  const int* pa = p1;
  const int* pb = p2;

  if (*pa < *pb)
    return -1;
  if (*pa > *pb)
    return 1;
  return 0;
}

size_t GraphFindNodeIndexById(tGraph* pGraph, int Id)
{
  tNode* pNode = bsearch(&Id,
                         pGraph->Nodes.pElements,
                         pGraph->Nodes.Count,
                         pGraph->Nodes.ElementSize,
                         &NodeIdComparator);

  if (pNode == NULL)
    return (size_t)-1;

  return pNode - (tNode*)pGraph->Nodes.pElements;
}

int GraphInsertNode(tGraph* pGraph, int Id, int Data)
{
  size_t idx = GraphFindNodeIndexById(pGraph, Id);
  tNode node;

  if (idx != (size_t)-1) // node with this Id already exist
    return 0;

  node.Id = Id;
  node.Data = Data;
  ArrayInit(&node.LinksTo, sizeof(int));
  ArrayInit(&node.LinksFrom, sizeof(int));

  if (!ArrayInsertElement(&pGraph->Nodes, pGraph->Nodes.Count, &node))
    return 0;

  qsort(pGraph->Nodes.pElements,
        pGraph->Nodes.Count,
        pGraph->Nodes.ElementSize,
        &NodeIdComparator); // maintain order for binary search

  return 1;
}

int GraphLinkNodes(tGraph* pGraph, int IdFrom, int IdTo)
{
  size_t idxFrom = GraphFindNodeIndexById(pGraph, IdFrom);
  size_t idxTo = GraphFindNodeIndexById(pGraph, IdTo);
  tNode *pFrom, *pTo;

  if (idxFrom == (size_t)-1 || idxTo == (size_t)-1) // one or both nodes don't exist
    return 0;

  pFrom = (tNode*)pGraph->Nodes.pElements + idxFrom;
  pTo = (tNode*)pGraph->Nodes.pElements + idxTo;

  // link IdFrom -> IdTo
  if (bsearch(&IdTo,
              pFrom->LinksTo.pElements,
              pFrom->LinksTo.Count,
              pFrom->LinksTo.ElementSize,
              &IntComparator) == NULL) // IdFrom doesn't link to IdTo yet
  {
    if (!ArrayInsertElement(&pFrom->LinksTo, pFrom->LinksTo.Count, &IdTo))
      return 0;

    qsort(pFrom->LinksTo.pElements,
          pFrom->LinksTo.Count,
          pFrom->LinksTo.ElementSize,
          &IntComparator); // maintain order for binary search
  }

  // back link IdFrom <- IdTo
  if (bsearch(&IdFrom,
              pTo->LinksFrom.pElements,
              pTo->LinksFrom.Count,
              pTo->LinksFrom.ElementSize,
              &IntComparator) == NULL) // IdFrom doesn't link to IdTo yet
  {
    if (!ArrayInsertElement(&pTo->LinksFrom, pTo->LinksFrom.Count, &IdFrom))
      return 0;

    qsort(pTo->LinksFrom.pElements,
          pTo->LinksFrom.Count,
          pTo->LinksFrom.ElementSize,
          &IntComparator); // maintain order for binary search
  }

  return 1;
}

int main(void)
{
  tGraph g;

  printf("\nCreating empty graph...\n");
  GraphInit(&g);
  GraphPrintNodes(&g);

  printf("\nInserting nodes...\n");
  GraphInsertNode(&g, 0, 0);
  GraphInsertNode(&g, 1, 101);
  GraphInsertNode(&g, 2, 202);
  GraphPrintNodes(&g);

  printf("\nLinking nodes...\n");
  GraphLinkNodes(&g, 0, 1);
  GraphLinkNodes(&g, 0, 2);
  GraphLinkNodes(&g, 1, 2);
  GraphLinkNodes(&g, 2, 1);
  GraphPrintNodes(&g);

  printf("\nDestroying graph...\n");
  GraphDestroy(&g);
  GraphPrintNodes(&g);

  // repeat
  printf("\nLet's repeat...\n");

  printf("\nCreating empty graph...\n");
  GraphInit(&g);
  GraphPrintNodes(&g);

  printf("\nInserting nodes...\n");
  GraphInsertNode(&g, 1, 111);
  GraphInsertNode(&g, 2, 222);
  GraphInsertNode(&g, 3, 333);
  GraphPrintNodes(&g);

  printf("\nLinking nodes...\n");
  GraphLinkNodes(&g, 1, 2);
  GraphLinkNodes(&g, 2, 3);
  GraphLinkNodes(&g, 3, 1);
  GraphPrintNodes(&g);

  printf("\nDestroying graph...\n");
  GraphDestroy(&g);
  GraphPrintNodes(&g);

  return 0;
}
