llrbtree 0.0.1

data/ext/llrbtree/tree.c

@@ -0,0 +1,478 @@
+/*
+ * MIT License
+ * Copyright (c) 2019 Kyuden Masahiro
+ */
+
+#include <stdlib.h>
+#include "tree.h"
+
+static int
+is_red(node_t *node)
+{
+    return node == NULL ? 0 : node->color == node_red;
+}
+
+static int
+is_black(node_t *node)
+{
+    return node == NULL ? 0 : node->color == node_black;
+}
+
+static node_t*
+rotate_left(node_t *upper)
+{
+    node_t *lower;
+
+    lower = upper->right;
+    upper->right = lower->left;
+    if (upper->right != NULL) {
+        upper->right->parent = upper;
+    }
+
+    lower->left = upper;
+    lower->parent = upper->parent;
+    lower->left->parent = lower;
+
+    lower->color = upper->color;
+    upper->color = node_red;
+
+    return lower;
+}
+
+static node_t*
+rotate_right(node_t *upper)
+{
+    node_t *lower;
+
+    lower = upper->left;
+    upper->left = lower->right;
+    if (upper->left != NULL) {
+        upper->left->parent = upper;
+    }
+
+    lower->right = upper;
+    lower->parent = upper->parent;
+    lower->right->parent = lower;
+
+    lower->color = upper->color;
+    upper->color = node_red;
+
+    return lower;
+}
+
+static void
+flip_color(node_t *node)
+{
+    is_red(node) ? (node->color = node_black) : (node->color = node_red);
+
+    if (node->left != NULL) {
+        is_red(node->left) ? (node->left->color = node_black) : (node->left->color = node_red);
+    }
+    if (node->right != NULL) {
+        is_red(node->right) ? (node->right->color = node_black) : (node->right->color = node_red);
+    }
+}
+
+static node_t*
+fix_up(node_t *node)
+{
+    if (is_red(node->right)) {
+        node = rotate_left(node);
+    }
+    if (is_red(node->left) && is_red(node->left->left)) {
+        node = rotate_right(node);
+    }
+    if (is_red(node->left) && is_red(node->right)) {
+        flip_color(node);
+    }
+
+    return node;
+}
+
+static node_t*
+move_red_left(node_t *node)
+{
+    flip_color(node);
+    if (node->right != NULL && is_red(node->right->left)) {
+        node->right = rotate_right(node->right);
+        node = rotate_left(node);
+        flip_color(node);
+    }
+
+    return node;
+}
+
+static node_t*
+move_red_right(node_t *node)
+{
+    flip_color(node);
+    if (node->left != NULL && is_red(node->left->left)) {
+        node = rotate_right(node);
+        flip_color(node);
+    }
+
+    return node;
+}
+
+static node_t*
+delete_min(tree_t *tree, node_t *node)
+{
+    if (node->left == NULL) {
+        tree->free_node(node, tree->context);
+        return NULL;
+    }
+    if (is_black(node->left) && (node->left->left == NULL || is_black(node->left->left))) {
+        node = move_red_left(node);
+    }
+
+    node->left = delete_min(tree, node->left);
+    return fix_up(node);
+}
+
+static node_t*
+min(node_t *node)
+{
+    while (node->left != NULL) {
+        node = node->left;
+    }
+    return node;
+}
+
+static void
+free_nodes(tree_t *tree, node_t *node)
+{
+    if (node == NULL) return;
+
+    free_nodes(tree, node->left);
+    free_nodes(tree, node->right);
+    tree->free_node(node, tree->context);
+}
+
+static int
+verify_bintree(tree_t *tree)
+{
+    node_t *first, *next;
+
+    first = tree_first(tree);
+
+    while (first != NULL && (next = tree_next(tree, first))) {
+        if (tree->compare(first->key, next->key, tree->context) >= 0) {
+            return 0;
+        }
+        first = next;
+    }
+    return 1;
+}
+
+static unsigned int
+verify_redblack(node_t *root)
+{
+    unsigned height_left, height_right;
+
+    if (root != NULL) {
+        height_left = verify_redblack(root->left);
+        height_right = verify_redblack(root->right);
+        if (height_left == 0 || height_right == 0) return 0;
+        if (height_left != height_right) return 0;
+        if (is_red(root)) {
+            if (is_red(root->left)) return 0;
+            if (is_red(root->right)) return 0;
+            return height_left;
+        }
+        if (is_red(root)) return 0;
+        return height_left + 1;
+    }
+    return 1;
+}
+
+static node_count_t
+verify_node_count(node_t *root)
+{
+    if (root == NULL) return 0;
+
+    return 1 + verify_node_count(root->left) + verify_node_count(root->right);
+}
+
+void
+tree_free(tree_t *tree)
+{
+    free_nodes(tree, tree->root_node);
+    tree->root_node = NULL;
+    tree->node_count = 0;
+}
+
+tree_t*
+tree_init(tree_t *tree, compare_t comp, alloc_node_t al, free_node_t fr, void *context)
+{
+    tree->compare = comp;
+    tree->alloc_node = al;
+    tree->free_node = fr;
+    tree->context = NULL;
+    tree->node_count = 0;
+    tree->root_node = NULL;
+    tree->context = context;
+    return tree;
+}
+
+int
+tree_verify(tree_t *tree)
+{
+    if (is_red(tree->root_node)) return 0;
+    if (tree->root_node->parent != NULL) return 0;
+    if (!verify_bintree(tree)) return 0;
+    if (!verify_redblack(tree->root_node)) return 0;
+    if (verify_node_count(tree->root_node) != tree->node_count) return 0;
+    return 1;
+}
+
+int
+tree_similar(const tree_t *left, const tree_t *right)
+{
+    if (left->compare != right->compare) return 0;
+    if (left->alloc_node != right->alloc_node) return 0;
+    if (left->free_node != right->free_node) return 0;
+    if (left->context != right->context) return 0;
+    return 1;
+}
+
+node_t*
+tree_lookup(tree_t *tree, const void *key)
+{
+    node_t *root = tree->root_node;
+    int result;
+
+    while (root != NULL) {
+        result = tree->compare(key, root->key, tree->context);
+        if (result < 0) {
+            root = root->left;
+        } else if (result > 0) {
+            root = root->right;
+        } else {
+            return root;
+        }
+    }
+
+    return NULL;
+}
+
+node_t*
+tree_lower_bound(tree_t *tree, const void *key)
+{
+    node_t *root = tree->root_node;
+    node_t *tentative = 0;
+
+    while (root != NULL) {
+        int result = tree->compare(key, root->key, tree->context);
+
+        if (result > 0) {
+            root = root->right;
+        } else if (result < 0) {
+            tentative = root;
+            root = root->left;
+        } else {
+            return root;
+        }
+    }
+
+    return tentative;
+}
+
+node_t*
+tree_upper_bound(tree_t *tree, const void *key)
+{
+    node_t *root = tree->root_node;
+    node_t *tentative = 0;
+
+    while (root != NULL) {
+        int result = tree->compare(key, root->key, tree->context);
+
+        if (result < 0) {
+            root = root->left;
+        } else if (result > 0) {
+            tentative = root;
+            root = root->right;
+        } else {
+            return root;
+        }
+    }
+
+    return tentative;
+}
+
+static node_t*
+recursive_insert(tree_t *tree, node_t *node, node_t *new_node, const void *key)
+{
+    int result = -1;
+    if (node == NULL) {
+        tree->node_count++;
+        return new_node;
+    }
+
+    result = tree->compare(key, node->key, tree->context);
+
+    if (result == 0) {
+        node->data = new_node->data;
+    } else if (result < 0) {
+        node->left = recursive_insert(tree, node->left, new_node, key);
+        node->left->parent = node;
+    } else {
+        node->right = recursive_insert(tree, node->right, new_node, key);
+        node->right->parent = node;
+    }
+
+    return fix_up(node);
+}
+
+int
+tree_insert(tree_t *tree, node_t *node, const void *key)
+{
+    tree->root_node = recursive_insert(tree, tree->root_node, node, key);
+    tree->root_node->color = node_black;
+    return 1;
+}
+
+static node_t*
+recursive_delete(tree_t *tree, node_t *node, const void *key)
+{
+    node_t *min_node;
+
+    if (node == NULL) return NULL;
+
+    if (tree->compare(key, node->key, tree->context) < 0) {
+        if (is_black(node->left) && (node->left->left == NULL || is_black(node->left->left))) {
+            node = move_red_left(node);
+        }
+        node->left = recursive_delete(tree, node->left, key);
+    } else {
+        if (is_red(node->left)) {
+            node = rotate_right(node);
+        }
+
+        if (is_black(node->right) && (node->right->left == NULL || is_black(node->right->left))) {
+            node = move_red_right(node);
+        }
+
+        if (tree->compare(key, node->key, tree->context) == 0) {
+            if (node->right == NULL) {
+                tree->free_node(node, tree->context);
+                return NULL;
+            }
+
+            min_node = min(node->right);
+            node->key = min_node->key;
+            node->data = min_node->data;
+            node->right = delete_min(tree, node->right);
+        } else {
+            node->right = recursive_delete(tree, node->right, key);
+        }
+    }
+
+    return fix_up(node);
+}
+
+void
+tree_delete(tree_t *tree, const void *key)
+{
+  tree->root_node = recursive_delete(tree, tree->root_node, key);
+  if (tree->root_node != NULL) {
+    tree->root_node->color = node_black;
+  }
+  tree->node_count--;
+}
+
+node_t*
+tree_first(tree_t *tree)
+{
+    node_t *root = tree->root_node, *left;
+
+    if (root != NULL) {
+        while ((left = root->left) != NULL) {
+            root = left;
+        }
+    }
+
+    return (root == NULL) ? NULL : root;
+}
+
+node_t*
+tree_last(tree_t *tree)
+{
+    node_t *root = tree->root_node, *right;
+
+    if (root != NULL) {
+        while ((right = root->right) != NULL) {
+            root = right;
+        }
+    }
+
+    return (root == NULL) ? NULL : root;
+}
+
+node_t*
+tree_next(tree_t *tree, node_t *curr)
+{
+    node_t *parent, *left;
+
+    if (curr->right != NULL) {
+        curr = curr->right;
+        while ((left = curr->left) != NULL) {
+            curr = left;
+        }
+        return curr;
+    }
+
+    parent = curr->parent;
+
+    while (parent != NULL && curr == parent->right) {
+        curr = parent;
+        parent = curr->parent;
+    }
+
+    return (parent == NULL) ? NULL : parent;
+}
+
+node_t*
+tree_prev(tree_t *tree, node_t *curr)
+{
+    node_t *parent, *right;
+
+    if (curr->left != NULL) {
+        curr = curr->left;
+        while ((right = curr->right) != NULL) {
+            curr = right;
+        }
+        return curr;
+    }
+
+    parent = curr->parent;
+
+    while (parent != NULL && curr == parent->left) {
+        curr = parent;
+        parent = curr->parent;
+    }
+
+    return (parent == NULL) ? NULL : parent;
+}
+
+int
+tree_isempty(tree_t *tree)
+{
+    return tree->node_count == 0;
+}
+
+int
+tree_isfull(tree_t *tree)
+{
+    return tree->node_count == NODE_COUNT_T_MAX;
+}
+
+node_t*
+node_init(node_t *node, void *data)
+{
+    node->data = data;
+    node->parent = NULL;
+    node->left = NULL;
+    node->right = NULL;
+    node->color = node_red;
+    return node;
+}

data/ext/llrbtree/tree.h

@@ -0,0 +1,63 @@
+/*
+ * MIT License
+ * Copyright (c) 2019 Kyuden Masahiro
+ */
+
+#ifndef LLRB_TREE_H
+#define LLRB_TREE_H
+
+#include <limits.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NODE_COUNT_T_MAX ULONG_MAX
+
+typedef enum { node_red, node_black } node_color_t;
+
+typedef struct node_t {
+    struct node_t *left;
+    struct node_t *right;
+    struct node_t *parent;
+    node_color_t color;
+    const void *key;
+    void *data;
+} node_t;
+
+typedef unsigned long node_count_t;
+typedef int (*compare_t)(const void *, const void *, void *);
+typedef node_t *(*alloc_node_t)(void *);
+typedef void (*free_node_t)(node_t *, void *);
+
+typedef struct tree_t {
+    node_t *root_node;
+    node_count_t node_count;
+    compare_t compare;
+    alloc_node_t alloc_node;
+    free_node_t free_node;
+    void *context;
+} tree_t;
+
+extern void tree_free(tree_t *);
+extern tree_t *tree_init(tree_t *, compare_t, alloc_node_t, free_node_t, void *);
+extern int tree_verify(tree_t *);
+extern int tree_similar(const tree_t *, const tree_t *);
+extern node_t *tree_lookup(tree_t *, const void *);
+extern node_t *tree_lower_bound(tree_t *, const void *);
+extern node_t *tree_upper_bound(tree_t *, const void *);
+extern int tree_insert(tree_t *, node_t *, const void *);
+extern void tree_delete(tree_t *, const void *);
+extern node_t *tree_first(tree_t *);
+extern node_t *tree_last(tree_t *);
+extern node_t *tree_next(tree_t *, node_t *);
+extern node_t *tree_prev(tree_t *, node_t *);
+extern int tree_isempty(tree_t *);
+extern int tree_isfull(tree_t *);
+extern node_t *node_init(node_t *, void *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/lib/llrbtree/version.rb

@@ -0,0 +1,3 @@
+class LLRBTree
+  VERSION = '0.0.1'
+end

data/lib/llrbtree.rb

@@ -0,0 +1,2 @@
+require 'llrbtree/llrbtree'
+require 'llrbtree/version'

data/llrbtree.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |spec|
+  spec.name          = 'llrbtree'
+  spec.version       = '0.0.1'
+  spec.authors       = ['kyuden']
+  spec.email         = ['msmsms.um@gmail.com']
+
+  spec.summary       = %q{Left-Leaning Red-Black Tree for Ruby.}
+  spec.description   = %q{Left-Leaning Red-Black Tree for Ruby.}
+  spec.homepage      = 'https://github.com/kyuden/llrbtree'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.extensions = %w[ext/llrbtree/extconf.rb]
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'test-unit'
+  spec.add_development_dependency 'rake-compiler'
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: llrbtree
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- kyuden
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Left-Leaning Red-Black Tree for Ruby.
+email:
+- msmsms.um@gmail.com
+executables: []
+extensions:
+- ext/llrbtree/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/llrbtree/depend
+- ext/llrbtree/extconf.rb
+- ext/llrbtree/llrbtree.c
+- ext/llrbtree/tree.c
+- ext/llrbtree/tree.h
+- lib/llrbtree.rb
+- lib/llrbtree/version.rb
+- llrbtree.gemspec
+homepage: https://github.com/kyuden/llrbtree
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Left-Leaning Red-Black Tree for Ruby.
+test_files: []