Data Structure Visualization Helper Functions

function createLinkedList<T>(arr: T[]): ListNode<T> | null;

def create_linked_list(arr: List[T]) -> Optional[ListNode]

template <typename T> ListNode<T> *createLinkedList(const vector<T> &vec);

const listHead = createLinkedList([1, 2, 3])

list_head = create_linked_list([1, 2, 3])

ListNode<int>* listHead = createLinkedList(vector<int>{1, 2, 3});

function linkedListToArray<T>(head: ListNode<T> | null): T[];

def linked_list_to_array(head: Optional[ListNode]) -> List[T]:

template <typename T> vector<T> linkedListToArray(ListNode<T> *head);

const arr = linkedListToArray(listHead) // [1, 2, 3]

arr = linked_list_to_array(list_head)  # [1, 2, 3]

vector<int> arr = linkedListToArray(listHead); // {1, 2, 3}

function createQueue(input: string | (string | number)[]): Queue;

def create_queue(s: str | list) -> Optional[Queue]:

template <typename T> std::queue<T> createQueue(const std::vector<T> &vec);

const queue1 = createQueue("abc") // Queue with elements 'a', 'b', 'c'
const queue2 = createQueue([1, 2, 3]) // Queue with elements 1, 2, 3

queue1 = create_queue("abc")  # Queue with elements 'a', 'b', 'c'
queue2 = create_queue([1, 2, 3])  # Queue with elements 1, 2, 3

auto queue1 = createQueue(vector<char>{'a', 'b', 'c'});
auto queue2 = createQueue(vector<int>{1, 2, 3});

function queueToArray(queue: Queue): (string | number)[];

def queue_to_array(queue: Queue) -> List[Union[str, int]]:

template <typename T> std::vector<T> queueToArray(std::queue<T> &q);

const arr = queueToArray(queue) // [1, 2, 3]

arr = queue_to_array(queue)  # [1, 2, 3]

vector<int> arr = queueToArray(queue); // {1, 2, 3}

function createBinaryTree(arr: (string | number | null)[]): TreeNode | null;

def create_binary_tree(arr: List[Optional[Union[str, int]]]) -> Optional[BinaryTreeNode]:

// -1||"-1" for empty nodes
template <typename T> TreeNode<T> *createBinaryTree(const vector<T> &arr);

const root = createBinaryTree([1, 2, 3, null, 4])

root = create_binary_tree([1, 2, 3, None, 4])

TreeNode<int>* root = createBinaryTree(vector<int>{1, 2, 3, -1, 4});

function binaryTreeToArray(root: TreeNode | null): (string | number | null)[];

def binary_tree_to_array(root: Optional[BinaryTreeNode]) -> List[Optional[Union[str, int]]]:

template <typename T> vector<T> binaryTreeToArray(TreeNode<T> *root);

const arr = binaryTreeToArray(root) // [1, 2, 3, null, 4]

arr = binary_tree_to_array(root)  # [1, 2, 3, None, 4]

vector<optional<int>> arr = binaryTreeToArray(root); // {1, 2, 3, 0, 4}

function createStack<T extends string | number>(arr: T[]): Stack<T>;

def create_stack(arr: List[T]) -> Stack[T]:

template <typename T> std::stack<T> createStack(const std::vector<T> &vec);

const stack = createStack([1, 2, 3]) // Stack with 3 at top

stack = create_stack([1, 2, 3])  # Stack with 3 at top

stack<int> s = createStack(vector<int>{1, 2, 3}); // 3 at top

function stackToArray<T extends string | number>(stack: Stack<T>): T[];

def stack_to_array(stack: Stack[T]) -> List[T]:

template <typename T> std::vector<T> stackToArray(std::stack<T> &s);

const arr = stackToArray(stack) // [3, 2, 1]

arr = stack_to_array(stack)  # [3, 2, 1]

vector<int> arr = stackToArray(stack); // {3, 2, 1}

function createGraph(data: T, directedGraph: boolean = true): T;

def create_graph(data: T, directedGraph: bool = True) -> T:

// Create a directed weighted graph
const graph1 = Graph({
    A: { B: 4, C: 5 },
    B: { C: -2, D: 3 },
    C: { D: 4 },
    D: { E: 2 },
    E: {},
  })

// Create an undirected weighted graph
const graph2 = Graph(
  {
    A: { B: 1, C: 4 },
    B: { A: 1, C: 2, D: 5 },
    C: { A: 4, B: 2, D: 1 },
    D: { B: 5, C: 1 },
  },
  false
)

// Create a directed unweighted graph
const graph3 = Graph({
  '数据结构': ["算法"],
  '算法': ["机器学习"],
  '数学': ["机器学习", "深度学习"],
  '机器学习': ["深度学习"],
  '深度学习': [],
  'Python基础': ["数据结构", "数学"],
})

# Create a directed weighted graph
graph1 = Graph({
    'A': {'B': 4, 'C': 5},
    'B': {'C': -2, 'D': 3},
    'C': {'D': 4},
    'D': {'E': 2},
    'E': {}
})

# Create an undirected weighted graph
graph2 = Graph({
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'C': 2, 'D': 5},
    'C': {'A': 4, 'B': 2, 'D': 1},
    'D': {'B': 5, 'C': 1}
}, False)

# Create a directed unweighted graph
graph3 = Graph({
    '数据结构': ['算法'],
    '算法': ['机器学习'],
    '数学': ['机器学习', '深度学习'],
    '机器学习': ['深度学习'],
    '深度学习': [],
    'Python基础': ['数据结构', '数学']
})