Add skew-heap

Author: nojima

skew-heap-cpp/skew_heap.hpp

@@ -0,0 +1,49 @@
+#pragma once
+#include <memory>
+
+namespace skewheap {
+
+template<typename T>
+struct Node {
+    T x;
+    Node* l;
+    Node* r;
+    Node* parent;
+
+    static Node<T>* empty() {
+        return nullptr;
+    }
+
+    static Node<T>* singleton(T x) {
+        return new Node<T>{x, nullptr, nullptr};
+    }
+
+    static Node<T>* meld(Node<T>* a, Node<T>* b, Node<T>* parent) {
+        if (a == nullptr && b == nullptr) {
+            return nullptr;
+        }
+        if (a == nullptr) {
+            b->parent = parent;
+            return b;
+        }
+        if (b == nullptr) {
+            a->parent = parent;
+            return a;
+        }
+        if (a->x > b->x) std::swap(a, b);
+        a->r = meld(a->r, b, a);
+        std::swap(a->l, a->r);
+        a->parent = parent;
+        return a;
+    }
+
+    Node* push(T x) {
+        return meld(this, singleton(x));
+    }
+
+    T pop() {
+        meld(l, r);
+    }
+};
+
+} // namespace skewheap

skew-heap/Cargo.lock

@@ -0,0 +1,6 @@
+[package]
+name = "skew-heap"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

skew-heap/Cargo.toml

@@ -0,0 +1,164 @@
+use std::{
+    mem::{offset_of, swap},
+    ptr::null_mut,
+};
+
+#[derive(Debug)]
+pub struct Hook {
+    parent: *mut Hook,
+    left: *mut Hook,
+    right: *mut Hook,
+}
+
+#[derive(Debug)]
+pub struct Entry {
+    x: i64,
+
+    parent: *mut Entry,
+    left: *mut Entry,
+    right: *mut Entry,
+}
+
+impl Entry {
+    pub fn new(x: i64) -> Entry {
+        Entry {
+            x,
+            parent: std::ptr::null_mut(),
+            left: std::ptr::null_mut(),
+            right: std::ptr::null_mut(),
+        }
+    }
+}
+
+pub fn meld(mut a: *mut Entry, mut b: *mut Entry, parent: *mut Entry) -> *mut Entry {
+    if a.is_null() {
+        if b.is_null() {
+            return null_mut();
+        }
+        unsafe { (*b).parent = parent };
+        return b;
+    }
+    if b.is_null() {
+        unsafe { (*a).parent = parent };
+        return a;
+    }
+    unsafe {
+        if (*a).x > (*b).x {
+            swap(&mut a, &mut b);
+        }
+        (*a).right = meld((*a).right, b, a);
+        swap(&mut (*a).left, &mut (*a).right);
+        (*a).parent = parent;
+    }
+    a
+}
+
+pub unsafe fn meld_hook<Entry: Ord, const OFFSET: usize>(
+    mut a: *mut Hook,
+    mut b: *mut Hook,
+    parent: *mut Hook,
+) -> *mut Hook {
+    if a.is_null() {
+        if b.is_null() {
+            return null_mut();
+        }
+        unsafe { (*b).parent = parent };
+        return b;
+    }
+    if b.is_null() {
+        unsafe { (*a).parent = parent };
+        return a;
+    }
+    unsafe {
+        let entry_a = a.byte_sub(OFFSET) as *const Entry;
+        let entry_b = b.byte_sub(OFFSET) as *const Entry;
+        if entry_a > entry_b {
+            swap(&mut a, &mut b);
+        }
+        (*a).right = meld_hook::<Entry, OFFSET>((*a).right, b, a);
+        swap(&mut (*a).left, &mut (*a).right);
+        (*a).parent = parent;
+    }
+    a
+}
+
+// Pushes a new element into the heap and returns the new root
+pub fn push(root: *mut Entry, new_entry: *mut Entry) -> *mut Entry {
+    meld(root, new_entry, null_mut())
+}
+
+// Returns the new root and the removed minimum element
+pub fn pop_min(root: *mut Entry) -> (*mut Entry, *mut Entry) {
+    if root.is_null() {
+        return (null_mut(), null_mut());
+    }
+    let new_root = meld(
+        unsafe { (*root).left },
+        unsafe { (*root).right },
+        null_mut(),
+    );
+    unsafe {
+        (*root).left = null_mut();
+        (*root).right = null_mut();
+        (*root).parent = null_mut();
+    }
+    (new_root, root)
+}
+
+// Unlinks the entry from the heap and returns new root
+pub fn unlink(root: *mut Entry, entry: *mut Entry) -> *mut Entry {
+    // If the entry is the root, just pop it
+    if entry == root {
+        let (new_root, _) = pop_min(root);
+        return new_root;
+    }
+    assert_ne!(unsafe { (*entry).parent }, null_mut());
+
+    let subtree = meld(
+        unsafe { (*entry).left },
+        unsafe { (*entry).right },
+        unsafe { (*entry).parent },
+    );
+    // Replace the link from the parent node to the entry with the subtree
+    unsafe {
+        if (*(*entry).parent).left == entry {
+            (*(*entry).parent).left = subtree;
+        } else {
+            (*(*entry).parent).right = subtree;
+        }
+    }
+    // Clear the links from the entry
+    unsafe {
+        (*entry).left = null_mut();
+        (*entry).right = null_mut();
+        (*entry).parent = null_mut();
+    }
+    // The root of the heap does not change, so return it as is
+    root
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_skew_heap() {
+        use super::{pop_min, push, unlink, Entry};
+        let mut root = std::ptr::null_mut();
+        let mut entries = vec![];
+        for i in 0..10 {
+            let mut entry = Box::new(Entry::new(i));
+            root = push(root, entry.as_mut() as *mut Entry);
+            entries.push(entry);
+        }
+        /*
+        for entry in entries.iter() {
+            let (new_root, min_entry) = pop_min(root);
+            assert_eq!(unsafe { (*min_entry).x }, unsafe { (**entry).x });
+            root = new_root;
+        }
+        */
+        for mut entry in entries {
+            root = unlink(root, entry.as_mut() as *mut Entry);
+        }
+        assert!(root.is_null());
+    }
+}

skew-heap/src/intrusive_skew_heap.rs

@@ -0,0 +1,6 @@
+pub mod skewheap;
+pub mod intrusive_skew_heap;
+
+fn main() {
+    println!("Hello, world!");
+}

skew-heap/src/main.rs

@@ -0,0 +1,78 @@
+use std::mem::swap;
+
+pub enum SkewHeap<T: Ord> {
+    Empty,
+    Node(SkewNode<T>),
+}
+
+pub struct SkewNode<T: Ord> {
+    x: T,
+    l: Box<SkewHeap<T>>,
+    r: Box<SkewHeap<T>>,
+}
+
+impl<T: Ord> SkewHeap<T> {
+    pub fn singleton(x: T) -> SkewHeap<T> {
+        Self::Node(SkewNode {
+            x,
+            l: Box::new(Self::Empty),
+            r: Box::new(Self::Empty),
+        })
+    }
+
+    pub fn is_empty(&self) -> bool {
+        match self {
+            Self::Empty => true,
+            _ => false,
+        }
+    }
+
+    pub fn push(self, x: T) -> SkewHeap<T> {
+        Self::merge(self, Self::singleton(x))
+    }
+
+    pub fn pop_min(self) -> (Option<T>, SkewHeap<T>) {
+        match self {
+            Self::Empty => (None, self),
+            Self::Node(node) => (Some(node.x), Self::merge(*node.l, *node.r)),
+        }
+    }
+
+    pub fn merge(a: SkewHeap<T>, b: SkewHeap<T>) -> SkewHeap<T> {
+        use SkewHeap::*;
+        match (a, b) {
+            (Empty, b) => b,
+            (a, Empty) => a,
+            (Node(mut a), Node(mut b)) => {
+                if a.x > b.x {
+                    swap(&mut a, &mut b);
+                }
+                a.r = Box::new(Self::merge(*a.r, Node(b)));
+                swap(&mut a.l, &mut a.r);
+                Node(a)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_skew_heap() {
+        use super::SkewHeap;
+        let mut heap = SkewHeap::Empty;
+        for x in [1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 8, 8, 9, 9, 9] {
+            heap = heap.push(x);
+        }
+        let mut v = Vec::new();
+        while !heap.is_empty() {
+            let (x, h) = heap.pop_min();
+            let Some(x) = x else {
+                panic!("pop_min should return Some(x)");
+            };
+            heap = h;
+            v.push(x);
+        }
+        assert_eq!(v, vec![1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 8, 8, 9, 9, 9]);
+    }
+}