一个python实现的有魔法方法（magic method）的单链表（静态链表）

做题要用到单链表，就实现了一个静态单链表，别管性能怎么样，能用就行。

为了方便，加入了一些魔法函数，使得它可以像list那样使用索引功能切片功能和for循环。

链表的node是一个二元的list，第一个元素是数据，第二个元素是下一个node的下标。

链表可以自动增长长度，一开始是8，每次翻一倍。

链表内部的那个list的头两个节点分别是空闲头结点和非空闲头结点。

向链表里增加数据有很多种方法，在示例里演示了4种，就是这一行的四种方法。

依次是初始化，函数，头插，尾添。

LinkList([7, 8])(range(3)).insert(6).append(5)

但实际上只有两个，一个头插，一个尾添。初始化和函数都是调用的append，所以都是尾添。

另外还可以使用赋值来增加新元素，但是没有实现完该功能，目前只能给某一个节点赋值。

删除也是没有实现完，只能删除某一个节点，如del ll[4]这样。

代码如下

# -*- coding: cp936 -*-
'''
这是一个静态单链表的实现
同时实现了一些magic method用于进行iter或者slice等等
需要注意的是，代码中的游标（指针）和key不是同一个概念
cur(pointer)是这个静态链表元素的实际下标
key是这个单链表元素的逻辑下标

未完，以后再写吧，写了一上午了，有些懒
2017.03.10
平善明
'''

class LinkList():
# a linklist implement by list with static
# 2017.03.10
# psm
def __init__(self, li=[]):
self.size = 10  # the real size of ll
self.li = [[None, i + 1] for i in range(self.size)]  # allocate
self.li[self.size - 1][1] = None  # the tail point None
self.li[0][0] = self.size - 2  # the length of unused space
self.li[0][1] = 2  # the pointer to the first unused space
self.li[1][0] = 0  # the length of ll(used space)
self.li[1][1] = None  # the pointer to the first used space

if li != []:  # add the items to the ll
self(li)
def insert(self, x):
# insert x at the begining of the LinkList
if self.li[0][0] < 1:
self.expandSize()  # if no space,expand the ll
nullCur = self.li[0][1]  # the pointer to the first unused space
self.li[0][0] -= 1  # unused space minus one
self.li[1][0] += 1  # used space add one
self.li[0][1] = self.li[nullCur][1]  # move unused pointer
self.li[nullCur][0] = x  # give the value to the new item
self.li[nullCur][1] = self.li[1][1]
self.li[1][1] = nullCur  # head link new node
return self
def append(self, x):
# insert x at the end of the LinkList
if self.li[0][0] < 1:
self.expandSize()  # if no space,expand the ll
tail = 1
while self.li[tail][1] != None:
tail = self.li[tail][1]  # get the tail of ll
nullCur = self.li[0][1]  # the pointer to the first unused space
self.li[0][0] -= 1  # unused space minus one
self.li[1][0] += 1  # used space add one
self.li[0][1] = self.li[nullCur][1]  # move unused pointer
self.li[nullCur][0] = x  # give the value to the new item
self.li[nullCur][1] = self.li[tail][1]  # new node become tail
self.li[tail][1] = nullCur  # old tail link new tail
return self
def delete(self, delCur):
self.li[1][0] -= 1  # used space minus one
self.li[0][0] += 1  # unused space add one
self.li[delCur][0] = None  # del the value
cur = 1
while self.li[cur][1] != delCur:
cur = self.li[cur][1]  # get the ahead pointer
self.li[cur][1] = self.li[delCur][1]  # the ahead pointer link the hinder item
self.li[delCur][1] = self.li[0][1]  # add the item to unused list
self.li[0][1] = delCur
return self
def expandSize(self):
self.li[0][1] = self.size
self.li += [[None, self.size + i + 1] for i in range(self.size - 2)]
self.li[-1][1] = None
self.li[0][0] = self.size - 2
self.size = len(self.li)
def pHead(self):
return self.li[1][1]
def empty(self):
return self.li[1][0] == 0
def length(self):
return self.li[1][0]
def printUsed(self):
for i in self:
print i,
print
return self
def printUnused(self):
ncur = self.li[0][1]
while ncur is not None:
print self.li[ncur],
ncur = self.li[ncur][1]
print
return self

# cur(or pointer,p) is the index in self.li
# key is the logical location
#    [[2, 8], [6, 2], [0, 4], [1, 5], [2, 3], [3, 6], [4, 7], [6, None], [None, 9], [None, None]]
# cur     0       1      2       3       4       5       6        7        8           9
# key                    0       2       1       3       4        5
def getPointerOfKey(self, key):
# as title,the key is int
if key < self.length():
if key >= 0:
num = 0
p = self.pHead()
while num != key:
p = self.li[p][1]
num += 1
return p
elif key < 0 and key > -self.length():
p0, p1 = self.pHead(), self.pHead()
for i in range(-key):
p1 = ll.li[p1][1]
while p1 is not None:
p0 = ll.li[p0][1]
p1 = ll.li[p1][1]
return p0
else:
raise KeyError('no this key\n')
else:
raise KeyError('no this key\n')
def reorganizeSliceKey(self, key):
# [::]->
# [::1]->[0:len(self):1]
# [::-1]->[len(self)-1:-1:-1]
# [1:]->[1:len(self):1]
start, stop, step = key.start, key.stop, key.step
# print start, stop, step
if key.stop == 9223372036854775807L:
stop = len(self)
if start is None and stop is None:
if step is None:
print 'haven"t implement'
return None
elif step > 0 :
start = 0
stop = len(self)
else:
start = len(self) - 1
stop = -1
if step is None:
step = 1
return start, stop, step
def __len__(self):
return self.li[1][0]
def __iter__(self):
self.ncur = self.li[1][1]  # next item's index
return self
def next(self):
if self.ncur is not None:
ret = self.li[self.ncur]
self.ncur = self.li[self.ncur][1]
return ret
else:
raise StopIteration
def __getitem__(self, key):
if isinstance(key, int):
return self.li[self.getPointerOfKey(key)]
elif isinstance(key, slice):
start, stop, step = self.reorganizeSliceKey(key)
# return a new ll
return LinkList([self.__getitem__(i)[0]
for i in range(start, stop, step)])
else:
raise TypeError('key must be int or slice\n')
def __setitem__(self, key, value):
# one -> one : change the value
# one -> many : del it, and add new item at this location
# many -> one : change the first value, del others
# little -> many : del them, and add new item at this location
# many -> little : change the ahead values, del others
if isinstance(key, int):  # one ->
if not (isinstance(value, list) or isinstance(value, tuple)):  # one -> one
self.li[self.getPointerOfKey(key)][0] = value
else:  # one -> many
pass
elif isinstance(key, slice):  # many ->
start, stop, step = key.start, key.stop, key.step
print start, stop, step
print 'haven"t implement'
return None
else:
raise TypeError('key must be int or slice\n')
def __delitem__(self, key):
# del one
# del many
if isinstance(key, int):
self.delete(self.getPointerOfKey(key))
elif isinstance(key, slice):
start, stop, step = key.start, key.stop, key.step
print start, stop, step
print 'haven"t implement'
return None
else:
raise TypeError('key must be int or slice\n')
def __call__(self, li):
if isinstance(li, list) or isinstance(li, tuple):
for i in li:  # add all item in li to the LinkList
self.append(i)
else:
self.append(li)  # add item to the LinkList
return self
def __reversed__(self):
pass
def __contains__(self, item):
pass

if __name__ == '__main__':
print '\ninit:'
ll = LinkList([7, 8])(range(3)).insert(6).append(5).printUsed()

print '\nall space:'
print ll.li

print '\nindex:', ll[-1], ll[0], ll[1]

print '\nslice:'
ll[:].printUsed()
ll[::-1].printUsed()
ll[1:3].printUsed()
ll[4:0:-1].printUsed()

print '\nassignment:'
ll[3] = 9
ll[-2] = 'a'
ll.printUsed()

print '\ndel:'
del ll[2]
del ll[-2]
ll.printUsed()

print '\niter:'
for i in ll:
print i,
print

运行结果示例：

init:
[6, 2] [7, 3] [8, 4] [0, 5] [1, 6] [2, 8] [5, None]

all space:
[[1, 9], [7, 7], [7, 3], [8, 4], [0, 5], [1, 6], [2, 8], [6, 2], [5, None], [None, None]]

index: [5, None] [6, 2] [7, 3]

slice:
[6, 3] [7, 4] [8, 5] [0, 6] [1, 7] [2, 8] [5, None]
[5, 3] [2, 4] [1, 5] [0, 6] [8, 7] [7, 8] [6, None]
[7, 3] [8, None]
[1, 3] [0, 4] [8, 5] [7, None]

assignment:
[6, 2] [7, 3] [8, 4] [9, 5] [1, 6] ['a', 8] [5, None]

del:
[6, 2] [7, 4] [9, 5] [1, 8] [5, None]

iter:
[6, 2] [7, 4] [9, 5] [1, 8] [5, None]