1/13
Vocabulary flashcards covering fundamental definitions, node structures, singly linked lists, doubly linked lists, and circular linked lists.
Node
An object in a linked list that consists of two parts: a data element that holds the actual value or information, and a link that stores the memory address (or reference) to the next node in the sequence.
Linked Nodes
A group of nodes connected to each other by object references, forming a chain-like structure.
Object Reference
In Java, the memory address where an object is stored.
start
The object reference that keeps track of the memory address of the first element or object of the linked list.
Self-Referential Class
A class design where an instance variable is declared of the same type as the class itself, such as the next field in the Node class being of type Node.
Null Reference
A reference variable state indicating it does not refer to any object, corresponding in memory to the address 0x0 (hexadecimal zero).
Locator Variable
A local reference variable (such as p) used to traverse a linked list by visiting each node one by one via reassignment (e.g., p = p.next).
SortedList
A class managing a sorted linked list that contains a private data member named first of type Node initialized to null, along with methods such as isEmpty() and insert().
Doubly Linked List
A linked data structure of sequentially linked nodes where each node contains two reference fields (links) pointing to the previous node and the next node in the sequence.
Sentinel Node
A specialized terminator node pointed to by the previous link of the beginning node and the next link of the ending node to facilitate list traversal.
head
The reference variable representing the first node in a doubly linked list implementation.
tail
The reference variable representing the last node in a doubly linked list implementation.
Circular Linked List
A variation of a linked list where the last node does not point to null, but instead points back to the first node, forming a closed loop.
Round-Robin Scheduling
An operating system CPU scheduling algorithm where each process receives a fixed time slice before moving to the end of the rotation, well suited for implementation via a circular linked list.