Skip to main content

How to Implement a Linked List Concept in Batch Script

In computer science, a Linked List is a data structure where each element (a "Node") contains both a piece of data and a "Pointer" to the next element in the sequence. Unlike standard arrays, linked lists can easily grow and shrink without reallocating large blocks of memory. While Batch isn't designed for complex pointers, we can simulate this using variable name mapping.

In this guide, we will demonstrate how to build a basic singly-linked list in Batch.

The Strategy: Dynamic Pointers​

  1. Each node is identified by a unique ID (e.g., NodeA).
  2. Store the data: set "NodeA_Data=Apple".
  3. Store the pointer: set "NodeA_Next=NodeB".
  4. The list "Ends" when a Next variable is set to NULL.
note

This structure avoids using sequential indices (e.g., ARR_1, ARR_2). Instead, nodes are linked via variable names, allowing you to insert a new node into the middle of the chain simply by updating one "Next" pointer, without shifting all subsequent indices.

Implementation Script​

@echo off
setlocal enabledelayedexpansion

echo --- LINKED LIST DEMONSTRATION ---

:: 1. Initialize Nodes
set "Root=NodeA"

:: Node A
set "NodeA_Data=Server-01"
set "NodeA_Next=NodeB"

:: Node B
set "NodeB_Data=Database-Alpha"
set "NodeB_Next=NodeC"

:: Node C
set "NodeC_Data=LoadBalancer"
set "NodeC_Next=NULL"

:: 2. Traverse the List
set "current=!Root!"

:traverse
if "!current!"=="NULL" (
    echo [END] Reached the end of the list.
    goto :done
)

:: Retrieve data for current node using double expansion
call set "data=%%!current!_Data%%"
echo Visiting Node [!current!]: !data!

:: Move to the next node
call set "current=%%!current!_Next%%"

goto :traverse

:done
endlocal
pause

Why Use a Linked List Concept in Batch?​

  1. Dynamic Relationships: If your script manages items that aren't strictly numbered (like a chain of dependent tasks), a linked list allows you to easily insert a new task in the middle of the chain by updating two pointers.
  2. Navigation History: Storing a path of "What happened next" without needing to manage a massive sequential index.
  3. Memory Preservation: You can delete a "Node" simply by clearing its variables and updating the Next pointer of the previous node to skip the deleted entry.

Visualizing the Structure​

  • Root variable holds NodeA.
  • NodeA tells the script: "My data is X, go to NodeB next."
  • NodeB tells the script: "My data is Y, go to NodeC next."
  • NodeC tells the script: "My data is Z, stop here."

Important Limitations​

warning

Linked lists are prone to "Circular References." If Node A points to Node B, and Node B points back to Node A, your script will enter an infinite loop. Always ensure your "Next" chain is unidirectional and eventually terminates in NULL.

  1. Complexity: Linked lists are harder to debug than standard arrays because you can't just look at %ARR_1%. You have to follow the chain.
  2. Access Speed: To find the 10th item, you must visit the previous 9 items. You cannot "Jump" straight to an index (Random Access is not possible).
  3. Infinite Loops: If you create a cycle, the script will loop forever. Always validate your pointer logic.

Best Practices​

  1. Use Unique Identifiers: Ensure every node has a truly unique ID. If two nodes share an ID, your pointer logic will collapse.
  2. Standardize Termination: Always use the same constant (like NULL or END) to signify the end of the list, and consistently check for that value during traversal.
tip

To "Delete" a node (e.g., NodeB) from the middle, set NodeA_Next to the value of NodeB_Next. This removes NodeB from the traversal path instantly without affecting NodeC.

Conclusion​

Simulating a linked list in Batch adds a level of architectural sophistication to your automation. It allows you to model complex, interdependent workflows that require flexible insertion and deletion. While standard arrays are easier for simple counts, the linked list concept is the foundation for building high-level behavioral scripts and dynamic task managers that adapt to changing data requirements in real-time.

Table of Contents