Two rules each.
Everything else follows.

// Monotonic stack: the next greater element.
// For each element, find the next one larger than it.
// Used in histogram problems, temperature problems,
// compiler optimisations, and event processing.
fn next_greater(arr: &[i32]) -> Vec<i32> {
    let n = arr.len();
    let mut result = vec![-1; n];       // -1 means none
    let mut stack: Vec<usize> = Vec::new(); // holds indices

    for i in 0..n {
        // while the current element beats the top index,
        // that index has found its next greater element
        while let Some(&top) = stack.last() {
            if arr[i] > arr[top] {
                result[top] = arr[i];
                stack.pop();
            } else {
                break;
            }
        }
        stack.push(i);
    }
    result
    // O(n): each element is pushed and popped at most once.
    // amortised O(1) each, despite the inner loop.
}

// A thread-safe queue using standard-library channels.
// Rust channels are lock-free queues internally.
use std::sync::mpsc;
use std::thread;

fn producer_consumer() {
    let (tx, rx) = mpsc::channel::<i32>();

    // producer: enqueues work
    let producer = thread::spawn(move || {
        for i in 0..10 {
            tx.send(i).unwrap(); // O(1) amortised, lock-free
        }
    });

    // consumer: dequeues and processes
    let consumer = thread::spawn(move || {
        while let Ok(val) = rx.recv() {
            println!("processing: {val}");
        }
    });

    producer.join().unwrap();
    consumer.join().unwrap();
    // The same producer-consumer pattern as the OS scheduler:
    // your processes are producers, the scheduler is the consumer,
    // the run queue is the channel between them.
}

/*
 * Monotonic stack in C: the next greater element.
 * Same algorithm, explicit stack management.
 */
#include <stdlib.h>
#include <string.h>

void next_greater(const int *arr, size_t n, int *result) {
    memset(result, -1, n * sizeof *result);

    int *stack = malloc(n * sizeof *stack); /* index stack */
    int  top   = -1;

    for (size_t i = 0; i < n; i++) {
        while (top >= 0 && arr[i] > arr[stack[top]]) {
            result[stack[top--]] = arr[i];
        }
        stack[++top] = (int)i;
    }
    free(stack);
    /* O(n) total: each index pushed and popped once. */
    /* C: you manage the stack memory by hand.        */
    /* Rust: Vec<usize> manages it for you.           */
}

/*
 * The Bitcoin Core thread-queue pattern.
 * The net thread enqueues messages.
 * The validation thread dequeues and processes them.
 * Simplified here without the threading primitives.
 */
typedef struct MsgNode {
    char            *payload;
    struct MsgNode  *next;
} MsgNode;

typedef struct {
    MsgNode *head;
    MsgNode *tail;
    /* real code also holds: pthread_mutex_t lock; */
    /* real code also holds: sem_t           items; */
} ThreadQueue;

void tq_enqueue(ThreadQueue *q, char *payload) {
    MsgNode *node = malloc(sizeof *node);
    node->payload = payload;
    node->next    = NULL;
    if (q->tail) q->tail->next = node;
    else         q->head = node;
    q->tail = node;
    /* O(1): append to the linked-list tail */
}

char *tq_dequeue(ThreadQueue *q) {
    if (!q->head) return NULL;
    MsgNode *node    = q->head;
    char    *payload = node->payload;
    q->head = node->next;
    if (!q->head) q->tail = NULL;
    free(node);
    return payload;
    /* O(1): remove from the linked-list head */
}

use std::collections::BinaryHeap;
use std::cmp::Ordering;

#[derive(Eq, PartialEq)]
struct MempoolEntry {
    fee_rate:    u64,   // sat/vbyte, higher is better
    size_vbytes: u32,
    txid:        [u8; 32],
}

impl Ord for MempoolEntry {
    fn cmp(&self, other: &Self) -> Ordering {
        // max-heap: the highest fee rate is extracted first
        self.fee_rate.cmp(&other.fee_rate)
    }
}
impl PartialOrd for MempoolEntry {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

fn build_block(
    mempool: &mut BinaryHeap<MempoolEntry>,
    block_weight_limit: u32,
) -> Vec<MempoolEntry> {
    let mut block = Vec::new();
    let mut weight_used = 0u32;

    while let Some(entry) = mempool.pop() {
        // pop() extracts the highest fee_rate: O(log n)
        if weight_used + entry.size_vbytes > block_weight_limit {
            mempool.push(entry); // does not fit, put it back
            break;
        }
        weight_used += entry.size_vbytes;
        block.push(entry);
    }
    block
    // This is what decides whose transaction confirms.
    // The priority queue decides financial priority.
}

/*
 * Same algorithm, explicit heap management.
 * Reuses the MaxHeap, TxEntry, and heap_pop
 * from the level 02 priority queue above.
 */
void build_block_c(MaxHeap *mempool,
                   uint32_t  weight_limit,
                   TxEntry  *block_out,
                   int      *block_size_out) {
    *block_size_out = 0;
    uint32_t used = 0;

    while (mempool->size > 0) {
        TxEntry top = mempool->data[0];      /* peek at the max */
        if (used + top.size_vbytes > weight_limit) break;
        heap_pop(mempool);                   /* extract max: O(log n) */
        block_out[(*block_size_out)++] = top;
        used += top.size_vbytes;
    }
    /* highest fee rate first, until the block is full */
}