Skip to content

Commit 0b3f4b7

Browse files
tickbhtickbh
committed
add zset
1 parent 976ca88 commit 0b3f4b7

File tree

6 files changed

+163
-59
lines changed

6 files changed

+163
-59
lines changed

‎examples/skip_list.rs‎

Lines changed: 21 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,30 @@
1+
// use algorithm::SkipList;
2+
// fn main() {
3+
// let mut val = SkipList::new();
4+
// val.insert(4);
5+
// val.insert(2);
6+
// val.insert(1);
7+
// let mut iter = val.iter();
8+
// assert_eq!(iter.next(), Some(&1));
9+
// assert_eq!(iter.next(), Some(&2));
10+
// assert_eq!(iter.next(), Some(&4));
11+
// assert_eq!(iter.next(), None);
12+
// let mut iter = val.iter().rev();
13+
// assert_eq!(iter.next(), Some(&4));
14+
// assert_eq!(iter.next(), Some(&2));
15+
// assert_eq!(iter.next(), Some(&1));
16+
// assert_eq!(iter.next(), None);
17+
// }
18+
119
use algorithm::SkipList;
220
fn main() {
321
let mut val = SkipList::new();
422
val.insert(4);
523
val.insert(2);
624
val.insert(1);
725
let mut iter = val.iter();
8-
assert_eq!(iter.next(), Some(&1));
9-
assert_eq!(iter.next(), Some(&2));
10-
assert_eq!(iter.next(), Some(&4));
11-
assert_eq!(iter.next(), None);
12-
let mut iter = val.iter().rev();
13-
assert_eq!(iter.next(), Some(&4));
14-
assert_eq!(iter.next(), Some(&2));
15-
assert_eq!(iter.next(), Some(&1));
26+
assert_eq!(iter.next(), Some((&1, 0)));
27+
assert_eq!(iter.next(), Some((&2, 1)));
28+
assert_eq!(iter.next(), Some((&4, 2)));
1629
assert_eq!(iter.next(), None);
1730
}

‎examples/zset.rs‎

Lines changed: 7 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1,27 +1,13 @@
1-
use std::borrow::Borrow;
2-
3-
use algorithm::{KeyRef, KeyWrapper, ZSet};
1+
use algorithm::ZSet;
42
fn main() {
53
let mut val = ZSet::new();
6-
7-
// let wrap = KeyWrapper::from_ref(&"bb");
8-
// let key_ref = KeyRef::new(&"bb");
9-
// println!("aaaaaaaaaaaaaa = {}", wrap.eq(key_ref.borrow()));
10-
11-
// val.add_or_update(11, 10);
12-
// val.add_or_update(22, 12);
13-
// assert_eq!(val.score(&22), 12);
14-
// assert_eq!(val.len(), 2);
15-
// assert_eq!(val.rank(&22), 0);
16-
// val.add_or_update(22, 9);
17-
// assert_eq!(val.rank(&22), 1);
18-
// assert_eq!(val.len(), 2);
19-
// val.add_or_update("aa", 10);
20-
val.add_or_update("xxx", 12);
21-
assert_eq!(val.score(&"xxx"), 12);
4+
val.add_or_update("aa", 10);
5+
val.add_or_update("bb", 12);
6+
assert_eq!(val.score(&"bb"), 12);
227
assert_eq!(val.len(), 2);
23-
assert_eq!(val.rank(&"bb"), 0);
8+
assert_eq!(val.rank(&"bb"), 2);
249
val.add_or_update("bb", 9);
2510
assert_eq!(val.rank(&"bb"), 1);
2611
assert_eq!(val.len(), 2);
27-
}
12+
13+
}

‎src/arr/mod.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,4 +5,4 @@ mod skip_list;
55

66
pub use circular_buffer::CircularBuffer;
77
pub use fix_vec::FixedVec;
8-
pub use skip_list::{SkipList, SkipNode};
8+
pub use skip_list::{SkipList, SkipNode, SkipIter};

‎src/arr/skip_list.rs‎

Lines changed: 27 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use std::{marker::PhantomData, ptr, usize::MAX};
1+
use std::{marker::PhantomData, ptr};
22

33
struct LevelType<T> {
44
pub forward: *mut SkipNode<T>,
@@ -29,6 +29,20 @@ pub struct SkipNode<T> {
2929
levels: Vec<LevelType<T>>,
3030
}
3131

32+
impl<T> SkipNode<T> {
33+
pub fn rank(&self) -> usize {
34+
let mut rank = 0;
35+
let mut backward = self.backward;
36+
unsafe {
37+
while !backward.is_null() {
38+
rank += (*backward).levels[0].span;
39+
backward = (*backward).backward;
40+
}
41+
}
42+
rank
43+
}
44+
}
45+
3246
/// 跳表, 链表的一种扩展, 相对更复杂, 但是效率更高
3347
///
3448
/// # Examples
@@ -392,26 +406,26 @@ impl<T: Default + PartialEq + PartialOrd> SkipList<T> {
392406
/// val.insert(2);
393407
/// val.insert(1);
394408
/// let mut iter = val.iter();
395-
/// assert_eq!(iter.next(), Some(&1));
396-
/// assert_eq!(iter.next(), Some(&2));
397-
/// assert_eq!(iter.next(), Some(&4));
409+
/// assert_eq!(iter.next(), Some((&1, 0)));
410+
/// assert_eq!(iter.next(), Some((&2, 1)));
411+
/// assert_eq!(iter.next(), Some((&4, 2)));
398412
/// assert_eq!(iter.next(), None);
399413
/// }
400414
/// ```
401-
pub fn iter(&self) -> Iter<'_, T> {
415+
pub fn iter(&self) -> SkipIter<'_, T> {
402416
let first = unsafe { (*self.header).levels[0].forward };
403-
Iter::new(self.length, first, self.tail)
417+
SkipIter::new(self.length, first, self.tail)
404418
}
405419
}
406420

407-
pub struct Iter<'a, T: 'a + Default + PartialEq + PartialOrd> {
421+
pub struct SkipIter<'a, T: 'a + Default + PartialEq + PartialOrd> {
408422
len: usize,
409423
header: *mut SkipNode<T>,
410424
tail: *mut SkipNode<T>,
411425
data: PhantomData<&'a ()>,
412426
}
413427

414-
impl<'a, T: Default + PartialEq + PartialOrd> Iter<'a, T> {
428+
impl<'a, T: Default + PartialEq + PartialOrd> SkipIter<'a, T> {
415429
pub fn new(len: usize, header: *mut SkipNode<T>, tail: *mut SkipNode<T>) -> Self {
416430
Self {
417431
len,
@@ -422,8 +436,8 @@ impl<'a, T: Default + PartialEq + PartialOrd> Iter<'a, T> {
422436
}
423437
}
424438

425-
impl<'a, T: Default + PartialEq + PartialOrd> Iterator for Iter<'a, T> {
426-
type Item = &'a T;
439+
impl<'a, T: Default + PartialEq + PartialOrd> Iterator for SkipIter<'a, T> {
440+
type Item = (&'a T, usize);
427441

428442
fn next(&mut self) -> Option<Self::Item> {
429443
if self.len == 0 {
@@ -435,7 +449,7 @@ impl<'a, T: Default + PartialEq + PartialOrd> Iterator for Iter<'a, T> {
435449
unsafe {
436450
let node = self.header;
437451
self.header = (*self.header).levels[0].forward;
438-
return Some(&(*node).score);
452+
return Some((&(*node).score, (*node).rank()));
439453
}
440454
}
441455

@@ -444,7 +458,7 @@ impl<'a, T: Default + PartialEq + PartialOrd> Iterator for Iter<'a, T> {
444458
}
445459
}
446460

447-
impl<'a, T: Default + PartialEq + PartialOrd> DoubleEndedIterator for Iter<'a, T> {
461+
impl<'a, T: Default + PartialEq + PartialOrd> DoubleEndedIterator for SkipIter<'a, T> {
448462
fn next_back(&mut self) -> Option<Self::Item> {
449463
if self.len == 0 {
450464
return None;
@@ -455,7 +469,7 @@ impl<'a, T: Default + PartialEq + PartialOrd> DoubleEndedIterator for Iter<'a, T
455469
unsafe {
456470
let node = self.tail;
457471
self.tail = (*self.tail).backward;
458-
return Some(&(*node).score);
472+
return Some((&(*node).score, (*node).rank()));
459473
}
460474
}
461475
}

‎src/key.rs‎

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
use std::any::{type_name, TypeId};
21
use std::borrow::Borrow;
32
use std::hash::Hash;
43
use std::ptr;
@@ -72,9 +71,6 @@ impl<Q: ?Sized + Hash> Hash for KeyWrapper<Q> {
7271

7372
impl<Q: ?Sized + PartialEq> PartialEq for KeyWrapper<Q> {
7473
fn eq(&self, other: &Self) -> bool {
75-
println!("aaa = {}", (self.0).eq(&other.0));
76-
println!("aaabbb = {}", (&self.0).eq(&other.0));
77-
println!("aaabbbccccc = {}", self.0 == other.0);
7874
(&self.0).eq(&other.0)
7975
}
8076
}
@@ -87,7 +83,6 @@ where
8783
Q: ?Sized,
8884
{
8985
fn borrow(&self) -> &KeyWrapper<Q> {
90-
println!("tttttttt = {} vv = {}", type_name::<K>(), type_name::<Q>());
9186
let key = unsafe { &*self.k }.borrow();
9287
KeyWrapper::from_ref(key)
9388
}

‎src/map/zset.rs‎

Lines changed: 107 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,8 @@
1-
use std::{
2-
borrow::Borrow,
3-
hash::{Hash, Hasher},
4-
mem, usize,
5-
};
6-
71
use std::collections::HashMap;
2+
use std::marker::PhantomData;
3+
use std::{borrow::Borrow, hash::Hash, mem, usize};
84

5+
use crate::arr::SkipIter;
96
use crate::{KeyRef, KeyWrapper, SkipList, SkipNode};
107

118
struct Context<K: Hash> {
@@ -52,7 +49,7 @@ impl<K: Hash> PartialOrd for Context<K> {
5249
/// val.add_or_update("aa", 10);
5350
/// val.add_or_update("bb", 12);
5451
/// assert_eq!(val.len(), 2);
55-
/// assert_eq!(val.rank(&"bb"), 0);
52+
/// assert_eq!(val.rank(&"bb"), 2);
5653
/// val.add_or_update("bb", 9);
5754
/// assert_eq!(val.rank(&"bb"), 1);
5855
/// assert_eq!(val.len(), 2);
@@ -89,11 +86,42 @@ impl<K: Hash + Eq> ZSet<K> {
8986
self.dict.len()
9087
}
9188

89+
90+
/// 清除集合
91+
///
92+
/// # Examples
93+
///
94+
/// ```
95+
/// use algorithm::ZSet;
96+
/// fn main() {
97+
/// let mut val = ZSet::new();
98+
/// val.add_or_update("aa", 10);
99+
/// val.add_or_update("bb", 12);
100+
/// assert_eq!(val.len(), 2);
101+
/// val.clear();
102+
/// assert_eq!(val.len(), 0);
103+
/// }
104+
/// ```
105+
///
92106
pub fn clear(&mut self) {
93107
self.dict.clear();
94108
self.zsl.clear();
95109
}
96110

111+
/// 包含键值
112+
///
113+
/// # Examples
114+
///
115+
/// ```
116+
/// use algorithm::ZSet;
117+
/// fn main() {
118+
/// let mut val = ZSet::new();
119+
/// val.add_or_update("aa", 10);
120+
/// val.add_or_update("bb", 12);
121+
/// assert_eq!(val.contains_key(&"aa"), true);
122+
/// }
123+
/// ```
124+
///
97125
pub fn contains_key<Q>(&mut self, k: &Q) -> bool
98126
where
99127
K: Borrow<Q>,
@@ -102,6 +130,21 @@ impl<K: Hash + Eq> ZSet<K> {
102130
self.dict.contains_key(KeyWrapper::from_ref(k))
103131
}
104132

133+
134+
/// 获取排序值
135+
///
136+
/// # Examples
137+
///
138+
/// ```
139+
/// use algorithm::ZSet;
140+
/// fn main() {
141+
/// let mut val = ZSet::new();
142+
/// val.add_or_update("aa", 10);
143+
/// val.add_or_update("bb", 12);
144+
/// assert_eq!(val.len(), 2);
145+
///
146+
/// }
147+
/// ```
105148
pub fn rank<Q>(&mut self, k: &Q) -> usize
106149
where
107150
K: Borrow<Q>,
@@ -113,7 +156,22 @@ impl<K: Hash + Eq> ZSet<K> {
113156
0
114157
}
115158

116-
pub fn erase<Q>(&mut self, k: &Q) -> bool
159+
/// 删除元素
160+
///
161+
/// # Examples
162+
///
163+
/// ```
164+
/// use algorithm::ZSet;
165+
/// fn main() {
166+
/// let mut val = ZSet::new();
167+
/// val.add_or_update("aa", 10);
168+
/// val.add_or_update("bb", 12);
169+
/// assert_eq!(val.len(), 2);
170+
/// assert!(val.remove(&"bb"));
171+
/// assert_eq!(val.len(), 1);
172+
/// }
173+
/// ```
174+
pub fn remove<Q>(&mut self, k: &Q) -> bool
117175
where
118176
K: Borrow<Q>,
119177
Q: Hash + Eq + ?Sized,
@@ -125,6 +183,23 @@ impl<K: Hash + Eq> ZSet<K> {
125183
}
126184
}
127185

186+
/// 添加或者更新值
187+
///
188+
/// # Examples
189+
///
190+
/// ```
191+
/// use algorithm::ZSet;
192+
/// fn main() {
193+
/// let mut val = ZSet::new();
194+
/// val.add_or_update("aa", 10);
195+
/// val.add_or_update("bb", 12);
196+
/// assert_eq!(val.len(), 2);
197+
/// val.add_or_update("bb", 14);
198+
/// assert_eq!(val.len(), 2);
199+
/// assert_eq!(val.score(&"bb"), 14);
200+
///
201+
/// }
202+
/// ```
128203
pub fn add_or_update(&mut self, key: K, mut score: isize) {
129204
if self.max_count == 0 || self.max_count == self.dict.len() {
130205
return;
@@ -140,18 +215,32 @@ impl<K: Hash + Eq> ZSet<K> {
140215
timestamp: 0,
141216
};
142217

143-
let key_ref = KeyRef::new(unsafe { &*context.key.as_ptr() });
144-
145-
218+
let key_ref = KeyRef::new(context.key.as_ptr());
146219
if let Some(v) = self.dict.remove(&key_ref) {
147220
let ret = self.zsl.update(unsafe { &(*v).score }, context);
221+
let key_ref = KeyRef::new(unsafe { (*ret).score.key.as_ptr() });
148222
self.dict.insert(key_ref, ret);
149223
} else {
150224
let ret = self.zsl.insert(context);
225+
let key_ref = KeyRef::new(unsafe { (*ret).score.key.as_ptr() });
151226
self.dict.insert(key_ref, ret);
152227
}
153228
}
154229

230+
/// 获取score值
231+
///
232+
/// # Examples
233+
///
234+
/// ```
235+
/// use algorithm::ZSet;
236+
/// fn main() {
237+
/// let mut val = ZSet::new();
238+
/// val.add_or_update("aa", 10);
239+
/// val.add_or_update("bb", 12);
240+
/// assert_eq!(val.score(&"bb"), 12);
241+
///
242+
/// }
243+
/// ```
155244
pub fn score<Q>(&mut self, k: &Q) -> isize
156245
where
157246
K: Borrow<Q>,
@@ -169,3 +258,10 @@ impl<K: Hash + Eq> Drop for ZSet<K> {
169258
self.clear();
170259
}
171260
}
261+
262+
263+
// pub struct Iter<'a, K: 'a + Default + PartialEq + PartialOrd> {
264+
// len: usize,
265+
// iter: SkipIter<&'a K>,
266+
// data: PhantomData<&'a ()>,
267+
// }

0 commit comments

Comments
 (0)