Summary of "doubly linked list: #1 Konsep dan Deklarasi Node"

Summary — main ideas, concepts, and lessons

This is the first video in a series about doubly linked lists. It explains the concept and how to declare/instantiate a node in code.
Later videos will cover list operations such as insertion (the next video will show “insert first”).
The presenter asks viewers to like/subscribe and references an earlier video that explains pointers.

Singly linked list node:
- Contains two parts — data and a pointer to the next node.
Doubly linked list node:
- Contains three parts — prev (pointer to previous node), data, and next (pointer to next node).
Example chain A — B — C:
- next links:
  - A.next -> B
  - B.next -> C
  - C.next -> NULL (end of list)
- prev links:
  - C.prev -> B
  - B.prev -> A
  - A.prev -> NULL (start of list)
Head and tail pointers:
- head (first) points to the first node; head->prev is NULL.
- tail (last) points to the last node; tail->next is NULL.

A pointer variable stores the address of a node. If you don’t understand pointers, watch the presenter’s previous pointer video.
Distinguish between:
- A struct variable (the actual node object stored directly).
- A pointer to a struct (an address referencing a node).
Field access:
- For a struct variable use the dot operator: a.data
- For a pointer to a struct use the arrow operator: p->data

Define the node type (struct) with prev, data, and next fields.
You can declare a struct variable directly and assign fields with the dot operator (.).
To create nodes dynamically, allocate memory:
- In C: use malloc (may need casting depending on style).
- In C++: use new (simpler syntax).
Use the arrow operator (->) to access fields through a pointer.

Define the node (struct) type
- Example (C-like pseudocode): c struct Node { Node *prev; int data; // or char, or any data type Node *next; };
Declare a concrete node variable (stored directly) c struct Node a; a.data = 10; // use '.' because 'a' is a struct variable
Declare a pointer to a node (will store addresses) c struct Node *p; // 'p' is a pointer to a Node
Allocate memory for a node and assign to pointer
- C (malloc): c p = (struct Node *) malloc(sizeof(struct Node)); p->data = 10; // use '->' because 'p' is a pointer
- C++ (new): cpp p = new Node; p->data = 10; // equivalent result, simpler syntax
Understand temporary memory vs pointer storage
- malloc / new create memory in the heap and return its address; you must store that address in a pointer variable to use the allocated node.
- Accessing fields:
  - If variable is a struct instance: use dot (a.data)
  - If variable is a pointer to struct: use arrow (p->data)
Doubly linked list special pointers and invariants
- head (first) points to the first node; head->prev should be NULL.
- tail (last) points to the last node; tail->next should be NULL.
Next steps
- The presenter will cover insertion operations (for example: insert first) for doubly linked lists in the next video.