What is a node in C? - c

Question

I'm working on cs50 pset5 speller, and in the lecture they introduce a new thing called nodes. What is a node? I didn't really understand what they said in the video. When I tried googling it, I got some sites that explained what a node is, but I didn't really understand. I'm new to c so I'm not accustomed to what I call 'coding words'. For instance, I found this on a site about nodes: A dynamic array can be extended by doubling the size but there is overhead associated with the operation of copying old data and freeing the memory associated with the old data structure. What is that supposed to mean? Please help me figure out what a node is because they seem important and useful, especially for pset5.
My node is defined like this:
typedef struct node
{
char word[LENGTH + 1];
struct node *next;
}
node;
Here is the link to the walk-through of speller pset5: https://cs50.harvard.edu/x/2020/psets/5/speller/

Answer 1

Node is a common terminology that is used to demonstrate a single block of linked list or tree or related data structures.
It is a convention to name it node, otherwise you can call it with any name.
Standard
C++
struct node{
int data;
int *next;
};
or in Python
class Node:
def __init__(self, data, next= None):
self.data = data
self.next = next
But you can call it with anyname
Not Standard
C++
struct my_own_name{
int data;
int *nextptr;
};
or in python
class my_own_name:
def __init__(self, data, next=None):
self.data = data
self.next = next

Answer 2

A "node" is a concept from graph theory. A graph consists of nodes (vertices) and edges that connect the nodes.
A node in C can be represented as a structure (a struct) that has all the necessary data elements "on board" to implement a graph. Optionally a structure may be required that represents the edges.
Example:
typedef struct NODE {
int node_id;
struct EDGE *edgelist;
} tNode;
typedef struct EDGE {
tNode *from, *to;
struct EDGE *next;
} tEdge;
Note: the term "node" may also be used in other contexts, for example the nodes of a binary tree, the nodes of a list, etc.

Answer 3

Expanding on Ahmad's answer, there are a number of data structures that are built of elements commonly called "nodes" - each node contains some data and some kind of reference (typically a pointer in C and C++) to one or more other nodes. For a singly-linked list, the node definition typically looks like
struct node {
data_t data; // for some arbitrary data_t type
struct node *next;
};
Each node contains the address of the following node. A graphical representation typically looks like
+------+------+ +------+------+ +------+------+
| data | next |------->| data | next |----->| data | next |------|||
+------+------+ +------+------+ +------+------+
You can also have doubly linked list, where each node points to both the preceding and following nodes:
struct node {
data_t data;
struct node *prev;
struct node *next;
};
And there are binary trees, where each node points to left and right child nodes:
struct node {
data_t data;
struct node *left;
struct node *right;
};
The use of the term "node" is just a common naming convention.
A dynamic array can be extended by doubling the size but there is overhead associated with the operation of copying old data and freeing the memory associated with the old data structure. What is that supposed to mean?
You can resize a dynamically allocated buffer using the realloc library function. For example, suppose we want to dynamically allocate a buffer to
store the string "foo". We'd write something like:
size_t bufsize = 4;
char *buffer = malloc( bufsize );
if ( buffer )
strcpy( buffer, "foo" );
We'll imagine the address returned from malloc is 0x1000:
+---+---+---+---+
0x1000: |'f'|'o'|'o'| 0 |
+---+---+---+---+
0x1004: | ? | ? | ? | ? |
+---+---+---+---+
... ... ... ...
Now, suppose we want to append the string "bar" to "foo". We didn't allocate a large enough buffer to do that, so we need to resize it using the realloc library function:
char *tmp = realloc( buffer, bufsize * 2 ); // double the buffer size
if ( tmp )
{
buffer = tmp;
bufsize *= 2;
strcat( buffer, "bar" );
}
else
{
// could not extend buffer, handle as appropriate
}
Now, if possible, realloc will just grab the space following the current buffer, so the result of that code would be:
+---+---+---+---+
0x1000: |'f'|'o'|'o'|'b'|
+---+---+---+---+
0x1004: |'a'|'r'| 0 | ? |
+---+---+---+---+
... ... ... ...
However, if the memory at 0x1004 had already been allocated for something else, then we can't do that. realloc will have to allocate a new buffer at a different address and copy the contents of the current buffer into it, then deallocate the original buffer. We'll imagine that the first region of free space large enough starts at 0x100c:
+---+---+---+---+
0x1000: |'f'|'o'|'o'| 0 |
+---+---+---+---+
0x1004: | ? | ? | ? | ? |
+---+---+---+---+
... ... ... ...
+---+---+---+---+
0x100c: | ? | ? | ? | ? |
+---+---+---+---+
0x1010: | ? | ? | ? | ? |
+---+---+---+---+
So realloc must first allocate the 8 bytes starting at 0x100c, then it must copy the contents of the current buffer to that new space:
+---+---+---+---+
0x1000: |'f'|'o'|'o'| 0 |
+---+---+---+---+
0x1004: | ? | ? | ? | ? |
+---+---+---+---+
... ... ... ...
+---+---+---+---+
0x100c: |'f'|'o'|'o'| 0 |
+---+---+---+---+
0x1010: | ? | ? | ? | ? |
+---+---+---+---+
and then finally release the space at 0x1000. We append "bar" to this new buffer, giving us:
+---+---+---+---+
0x1000: |'f'|'o'|'o'| 0 | // free'd memory is not overwritten
+---+---+---+---+
0x1004: | ? | ? | ? | ? |
+---+---+---+---+
... ... ... ...
+---+---+---+---+
0x100c: |'f'|'o'|'o'|'b'|
+---+---+---+---+
0x1010: |'a'|'r'| 0 | ? |
+---+---+---+---+
If realloc cannot find a large enough region to satisfy the request, it will return NULL and leave the current buffer in place. This is why we assign the return value of realloc to a different pointer variable - if we assigned that NULL back to buffer, then we'd lose our access to the original buffer.

Answer 4

A 'node' is not a C keyword.
The meaning of this:
A dynamic array can be extended by doubling the size but there is overhead associated with the operation of copying old data and freeing the memory associated with the old data structure
Dynamic allocation means that memory is allocated on the heap. The size of the memory space allocated does not have to be a compile time constant as in static memory allocation, and thus can be modified by reallocating more memory later on in the program's execution.
Overhead means the additional cost of doing an operation in comparison to some other way of doing the same operation. In this case increasing a dynamic array's size is an overhead in comparison with directly allocating the total required space.