From fbe424c2769bc5a457ede342fca3fdebdd1702a2 Mon Sep 17 00:00:00 2001 From: Andrew Golovashevich Date: Sat, 27 Dec 2025 14:35:11 +0300 Subject: [PATCH] goDown and swapNeighbors --- src/algos/go_down.rs | 50 +++++++++++++++++++++++++++++++++++++ src/algos/mod.rs | 2 ++ src/{ => algos}/swap/mod.rs | 0 src/algos/swap/neighbors.rs | 38 ++++++++++++++++++++++++++++ src/direction.rs | 2 ++ src/lib.rs | 2 +- src/parent2node/mod.rs | 2 +- src/swap/neighbors/mod.rs | 33 ------------------------ 8 files changed, 94 insertions(+), 35 deletions(-) create mode 100644 src/algos/go_down.rs create mode 100644 src/algos/mod.rs rename src/{ => algos}/swap/mod.rs (100%) create mode 100644 src/algos/swap/neighbors.rs delete mode 100644 src/swap/neighbors/mod.rs diff --git a/src/algos/go_down.rs b/src/algos/go_down.rs new file mode 100644 index 0000000..9b1eae9 --- /dev/null +++ b/src/algos/go_down.rs @@ -0,0 +1,50 @@ +use crate::BinaryTreeDirection; +use crate::context::BinaryTreeChildrenGetterContext; +use crate::directed::DirectedBinaryTreeChildrenGetterContext; +use crate::direction::DirectedBinaryTreeDirection; + +fn goDown( + ctx: &Ctx, + root: Ctx::NodeRef, + dir: BinaryTreeDirection, +) -> Ctx::NodeRef { + let mut p = root; + match dir { + BinaryTreeDirection::LEFT => loop { + match ctx.getLeftChild(p) { + None => return p, + Some(c) => p = c, + } + }, + + BinaryTreeDirection::RIGHT => loop { + match ctx.getRightChild(p) { + None => return p, + Some(c) => p = c, + } + }, + } +} + +fn goDownDirected( + ctx: &Ctx, + root: Ctx::NodeRef, + dir: DirectedBinaryTreeDirection, +) -> Ctx::NodeRef { + let mut p = root; + match dir { + DirectedBinaryTreeDirection::FORWARD => loop { + match ctx.getForwardChild(p) { + None => return p, + Some(c) => p = c, + } + }, + + DirectedBinaryTreeDirection::OPPOSITE => loop { + match ctx.getOppositeChild(p) { + None => return p, + Some(c) => p = c, + } + }, + } +} \ No newline at end of file diff --git a/src/algos/mod.rs b/src/algos/mod.rs new file mode 100644 index 0000000..7245ff7 --- /dev/null +++ b/src/algos/mod.rs @@ -0,0 +1,2 @@ +mod go_down; +mod swap; diff --git a/src/swap/mod.rs b/src/algos/swap/mod.rs similarity index 100% rename from src/swap/mod.rs rename to src/algos/swap/mod.rs diff --git a/src/algos/swap/neighbors.rs b/src/algos/swap/neighbors.rs new file mode 100644 index 0000000..fd5bed1 --- /dev/null +++ b/src/algos/swap/neighbors.rs @@ -0,0 +1,38 @@ +use crate::context::BinaryTreeParentGetterContext; +use crate::context::BinaryTreeParentSetterContext; +use crate::directed::DirectedBinaryTreeChildrenGetterContext; +use crate::directed::DirectedBinaryTreeChildrenSetterContext; +use crate::parent2node::clojure::Parent2NodeSetterClojure; + +unsafe fn swapNeighbors< + Ctx: DirectedBinaryTreeChildrenGetterContext + + DirectedBinaryTreeChildrenSetterContext + + BinaryTreeParentGetterContext + + BinaryTreeParentSetterContext, +>( + ctx: &mut Ctx, + parentLocation: &mut impl Parent2NodeSetterClojure, + grandparent: Option, + parent: Ctx::NodeRef, + child: Ctx::NodeRef, +) { + ctx.xSetParent(child, grandparent); + parentLocation.setChild(child); + ctx.xSetForwardChild(parent, ctx.getForwardChild(child)); + + let oppositeChild = ctx.getOppositeChild(parent); + ctx.xSetOppositeChild(parent, ctx.getOppositeChild(child)); + ctx.xSetOppositeChild(child, oppositeChild); + + if let Some(n) = ctx.getOppositeChild(child) { + ctx.setParent(n, child) + } + if let Some(n) = ctx.getOppositeChild(parent) { + ctx.setParent(n, parent) + } + if let Some(n) = ctx.getForwardChild(child) { + ctx.setParent(n, parent) + } + ctx.setForwardChild(child, parent); + ctx.setParent(parent, child); +} diff --git a/src/direction.rs b/src/direction.rs index 087ca2d..6c11ff3 100644 --- a/src/direction.rs +++ b/src/direction.rs @@ -1,7 +1,9 @@ +#[derive(PartialEq, Eq)] pub enum BinaryTreeDirection { LEFT, RIGHT, } +#[derive(PartialEq, Eq)] pub enum DirectedBinaryTreeDirection { FORWARD, OPPOSITE, diff --git a/src/lib.rs b/src/lib.rs index 20430a6..36c1c7b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,8 +1,8 @@ mod context; -mod swap; mod directed; mod direction; mod parent2node; +mod algos; pub use context::NodeRefContainer; pub use direction::BinaryTreeDirection; \ No newline at end of file diff --git a/src/parent2node/mod.rs b/src/parent2node/mod.rs index 852c13f..ca6dfb6 100644 --- a/src/parent2node/mod.rs +++ b/src/parent2node/mod.rs @@ -1,3 +1,3 @@ -mod clojure; +pub mod clojure; mod fixed_wrapper; mod dynamic_wrappers; \ No newline at end of file diff --git a/src/swap/neighbors/mod.rs b/src/swap/neighbors/mod.rs deleted file mode 100644 index d8267bc..0000000 --- a/src/swap/neighbors/mod.rs +++ /dev/null @@ -1,33 +0,0 @@ -use crate::swap::neighbors::context::OrientedNeighborSwapContext; - -mod context; -mod context_impl; - - - -fn swapNeighbors( - ctx: &mut Context, - grandparent: Option, - parent: Context::NodeRef, - child: Context::NodeRef, -) { - ctx.setParent(child, grandparent); - ctx.setGrandparentToParent(child); - ctx.setForwardChild(parent, ctx.getForwardChild(child)); - - let oppositeChild = ctx.getOppositeChild(parent); - ctx.setOppositeChild(parent, ctx.getOppositeChild(child)); - ctx.setOppositeChild(child, oppositeChild); - - if let Some(n) = ctx.getOppositeChild(child) { - ctx.setParent(n, Some(child)) - } - if let Some(n) = ctx.getOppositeChild(parent) { - ctx.setParent(n, Some(parent)) - } - if let Some(n) = ctx.getForwardChild(child) { - ctx.setParent(n, Some(parent)) - } - ctx.setForwardChild(child, Some(parent)); - ctx.setParent(parent, Some(child)); -}