Sorts a stack of three elements in ascending order:
This function sorts exactly three elements in a stack by identifying the maximum and minimum values, then performing the necessary swaps and rotations to order the elements.

// Initial stack A: 5 -> 3 -> 8 -> NULL
sort_3(&stack_a); 
// After sorting: 3 -> 5 -> 8 -> NULL

• Uses comparisons to determine the maximum and minimum elements in the stack.
• Applies sa(), ra(), and rra() operations to rearrange the elements in ascending order.

Sorts a stack with more than three elements using an advanced sorting algorithm:
This function handles large stacks by moving elements between two stacks (A and B), adjusting their positions based on calculated movements, and reordering the stacks until all elements are sorted.

// Initial stack A: 9 -> 4 -> 2 -> 8 -> 6 -> 5 -> NULL
// Initial stack B: (empty)
big_sort(&stack_a, &stack_b);
// After sorting stack A: 2 -> 4 -> 5 -> 6 -> 8 -> 9 -> NULL
// Stack B: (empty)

• Applies the Turk Algorithm, transferring elements between stacks A and B using efficient movements.
• Uses a combination of simultaneous rotations and independent movements to minimize the number of operations.

Sorts a stack based on its size using appropriate sorting strategies:
This function selects the appropriate sorting strategy depending on the size of stack A, using a mix of sorting algorithms tailored for different cases.

// Initial stack A: 7 -> 3 -> 4 -> 1 -> 6 -> 2 -> NULL
sort_cases(&stack_a);
// After sorting: 1 -> 2 -> 3 -> 4 -> 6 -> 7 -> NULL

• For small stacks (2 or 3 elements), it uses simple swaps or sort_3().
• For larger stacks (4 or more elements), it moves some elements to stack B, applies big_sort(), and then returns the sorted elements to stack A.

Finds the appropriate destination place for a source node within the destination stack:
This function determines the best position to insert a node (src) from the source stack into the destination stack (dest). It scans the destination stack to find a node that fits the correct ordering, considering boundaries and ordering criteria.

// Initial source node: content = 3
// Destination stack: 1 -> 5 -> 9 -> NULL
t_stack *place = return_dest_place(src_node, &stack_b); 
// The function identifies node with content = 5 as the best place for insertion.

• It checks for boundary conditions using ck_new_min_max().
• Iterates through the destination stack to find the most suitable insertion point for the source node.

Finds the node with the fewest total movements in the source stack:
This function searches the source stack (src) and identifies the node that requires the least number of movements to be properly placed in the destination stack.

// Initial source stack: 4(total_mov=3) -> 2(total_mov=1) -> 6(total_mov=2) -> NULL
t_stack *best_case = find_best_case(&stack_a);
// The function selects node with content = 2 as it has the fewest movements.

• Compares the total_mov value for each node and selects the one with the minimum value.

Moves a node to the top of stack A:
This function moves a specified node from stack A to the top, based on its movement orientation (mov_orientation). It uses either rotation (ra()) or reverse rotation (rra()) depending on the required direction.

// Initial stack A: 5 -> 3(mov=1, orientation=0) -> 8 -> 1 -> NULL
mv_node_to_top_a(node_a, &stack_a);
// After 2 rotations (ra):
// stack A becomes: 3 -> 8 -> 1 -> 5 -> NULL

• Repeatedly rotates or reverse rotates the stack until the node reaches the top, decreasing the mov value with each operation.

Moves two nodes simultaneously to the top of stack A and stack B:
This function moves two nodes (node_a and node_b) from stack A and stack B to the top of their respective stacks, using either double rotation (rr()) or double reverse rotation (rrr()), depending on their movement orientation.

// Initial stack A: 4 -> 6 -> 2(mov=2, orientation=1) -> NULL
// Initial stack B: 9 -> 7 -> 3(mov=2, orientation=1) -> NULL
mv_node_to_top_ab(node_a, node_b, &stack_a, &stack_b);
// After 2 simultaneous reverse rotations (rrr):
// stack A becomes: 2 -> 4 -> 6 -> NULL
// stack B becomes: 3 -> 9 -> 7 -> NULL

• If both nodes share the same movement orientation, the function performs simultaneous rotations (rr() for upward, rrr() for downward) to move them to the top of their respective stacks.

Moves a node to the top of stack B:
This function moves a specified node from stack B to the top, based on its movement orientation (mov_orientation). It uses either rotation (rb()) or reverse rotation (rrb()) depending on the required direction.

// Initial stack B: 9 -> 5 -> 7 -> 2(mov=1, orientation=1) -> NULL
mv_node_to_top_b(node_b, &stack_b);
// After 1 reverse rotation (rrb):
// stack B becomes: 2 -> 9 -> 5 -> 7 -> NULL

• Repeatedly rotates or reverse rotates the stack until the node reaches the top, decreasing the mov value with each operation.

Finds the right position to insert a node into the destination stack:
This function determines the optimal position for a node (src) to be inserted into the destination stack (dest), ensuring that the stack remains ordered.

// Initial source node: content = 4
// Destination stack: 2 -> 5 -> 8 -> NULL
t_stack *place = fit_between(src_node, &stack_b); 
// The function identifies node with content = 5 as the best place for insertion.

• The function first checks for boundary conditions (min/max values) and iterates through the destination stack to find the most suitable insertion point.

Rotates stack A to bring the smallest node to the top, completing the sorting process:
This function rotates stack A to move the node with the smallest value to the top, finalizing the sorting process after all other elements have been moved to stack A.

// Initial stack A: 5 -> 8 -> 1(mov=2, orientation=0) -> 3 -> NULL
rotate_to_finish(&stack_a, &stack_b);
// After 2 rotations (ra):
// stack A becomes: 1 -> 3 -> 5 -> 8 -> NULL

• Identifies the smallest node using ft_min() and rotates it to the top using mv_node_to_top_a().

Moves all nodes from stack B back to stack A, ensuring correct placement:
This function moves all nodes from stack B back to stack A in their correct order, using fit_between() to determine the proper place for each node and finalizing the sorting process.

// Initial stack A: 1 -> 9 -> 7 -> NULL
// Initial stack B: 8 -> 5 -> NULL
back_to_a(&stack_a, &stack_b);
// After moving all elements using fit_between():
// stack A: 5 -> 7 -> 8 -> 9 -> 1 -> NULL
// The stack is semi-ordered, and by applying one rotation (rra), the stack will become fully ordered.

• Moves nodes from stack B to stack A by placing them in their correct positions and then rotating stack A to finish the sorting process.

Previous ⬅️ • Top ⬆️ • Next ➡️