Python中 llist 模块的 sllist 类

llist 是 CPython 的扩展模块，提供了基本的链表结构。它们比出列甚至标准列表要快得多。

它是一个简单的单向数据结构，因此只能从头到最后一个节点遍历。单链表的每个节点都包含数据和它之前的节点的地址。简单来说，每个节点都指向它之后的节点。下图显示了单链表的一般结构：

在 llist 中，有一个 sllist 对象可以帮助成功实现单链表。

class llist.sllist([iterable])：返回一个从提供的可迭代对象初始化的新链表。如果没有给出可迭代对象，则生成链表但为空。

import llist
from llist import sllist, sllistiterator
  
lst = llist.sllist(['first', 'second', 'third'])
print(lst)

输出：

sllist([first, second, third])

sllist 支持以下属性：

first ：只读属性，打印列表的第一个属性，如果列表为空，则打印 None。
```
print(lst.first)
```
输出：
```
sllistnode(first)
```
last ：只读属性，返回列表的最后一个元素（尾），如果列表为空，则返回 None。
```
print(lst.last)
```
输出：
```
sllistnode(third)
```
size : 返回列表大小的只读属性
```
print(lst.size)
```
输出：
```
3
```

sslist 还支持以下方法：

append(x) ：将 x 添加到列表的右侧并返回一个插入的 sllist 节点。如果 x 已经是一个 sllist 节点，则创建一个新节点并使用从 x 中提取的值进行初始化。
```
lst.append('fourth')
print(lst)
```
输出：
```
sllist([first, second, third, fourth])
```
appendleft(x) ：将 x 添加到列表的左侧并返回一个插入的 sllist 节点。如果 x 已经是一个 sllist 节点，则创建一个新节点并使用从 x 中提取的值进行初始化。
```
lst.appendleft('fourth')
print(lst)
```
输出：
```
sllist([fourth, first, second, third])
```
appendright(x) ：将 x 添加到列表的右侧并返回一个插入的 sllist 节点。如果 x 已经是一个 sllist 节点，则创建一个新节点并使用从 x 中提取的值进行初始化。
```
lst.appendright('fourth')
print(lst)
```
输出：
```
sllist([first, second, third, fourth])
```
clear()从列表中清除所有节点。
```
lst.clear()
print(lst)
```
输出：
```
sllist()
```

extend(iterable) ：将可迭代的元素附加到列表的右侧

lst.extend(['fourth', 'fifth'])
print(lst)

输出：

sllist([first, second, third, fourth, fifth])

extendleft(iterable) ：将可迭代的元素附加到列表的左侧。

lst.extendleft(['fourth', 'fifth'])
print(lst)

输出：

sllist([fifth, fourth, first, second, third])

extendright(iterable) ：将可迭代的元素附加到列表的右侧

lst.extend(['fourth', 'fifth'])
print(lst)

输出：

sllist([first, second, third, fourth, fifth])

insertafter(x, node) ：在指定节点之后插入x，参数x应该是一个sllist节点，x的值被提取出来，给要插入的节点。
```
node = lst.nodeat(0)
lst.insertafter('fourth', node)
print(lst)
```
输出：
```
sllist([first, fourth, second, third])
```
insertbefore(x, node) ：在指定节点之前插入x，参数x应该是一个sllist节点，x的值被提取出来给要插入的节点。
```
node = lst.nodeat(1)
lst.insertbefore('fourth', node)
print(lst)
```
输出：
```
sllist([first, fourth, second, third])
```
nodeat() ：返回指定索引处的节点。如果从右侧开始计数，则允许使用负索引。
```
node = lst.nodeat(1)
print(node)
```
输出：
```
sllistnode(second)
```
pop() ：从列表的右侧删除一个元素。
```
lst.pop()
print(lst)
```
输出：
```
sllist([first, second])
```
popleft() ：从列表的左侧删除一个元素。
```
lst.popleft()
print(lst)
```
输出：
```
sllist([second, third])
```
popright() ：从列表的右侧删除一个元素。
```
lst.pop()
print(lst)
```
输出：
```
sllist([first, second])
```

remove(node) : 移除指定节点

node = lst.nodeat(1)
lst.remove(node)
print(lst)

输出：

sllist([first, third])

rotate(n) ：旋转列表 n 步。如果 n 为正，则向右旋转，如果为负，则向左旋转。
```
lst.rotate(-1)
print(lst)
```
输出：
```
sllist([second, third, first])
```

除了这些方法之外，sllist 还支持迭代、cmp(lst1, lst2)、丰富的运算符、常数时间 len(lst)、hash(lst) 和下标引用 lst[1234] 用于按索引访问元素。

我们进一步讨论更多与 sllist 相关的 llist 对象：

列表节点

在单链表中实现一个节点，如果提供了值，则可以选择对其进行初始化。

node = llist.sllistnode('zeroth')
print(node)

输出：

sllistnode(zeroth)

该对象还支持以下属性：

node = lst.nodeat(0)
print(node.next)
print(node.value)

输出：

sllistnode(second)
first

slistiterator 对象

返回一个新的单链表迭代器。这些对象不是由用户创建的，而是由 sllist.__iter__() 方法返回以保持迭代状态。通过 sllistiterator 接口迭代将直接产生存储在节点中的值。

import llist 
from llist import sllist
  
lst = llist.sllist(['first', 'second', 'third'])
  
for value in lst:
  print(value)

输出：

first
second
third