class LNode(object):
def __init__(self):
self._data = None
self._next = None
@property
def data(self):
return self._data
@data.setter
def data(self, data):
self._data = data
@property
def next(self):
return self._next
@next.setter
def next(self, node):
assert (node is None or isinstance(node, LNode)), 'Type error'
self._next = node
def __str__(self):
s = ""
ids = []
node = self
indent = ' '
i = 0
while node:
if id(node) in ids:
break
ids.append(id(node))
s += indent * i + "=" * 20 + '\n'
s += indent * i + "id:" + str(id(node)) + '\n'
if hasattr(node, 'prior'):
s += indent * i + "prior:" + str(id(node.prior)) + '\n'
s += indent * i + "data:" + str(node.data) + '\n'
s += indent * i + "next:" + str(id(node.next)) + '\n'
i += 1
node = node.next
return s
def create4():
L = r = LNode()
r.next = None
for i in range(5):
p = LNode()
p.data = i
r.next = p
r = p
return L
print create4()
====================
id:140595582998416
data:None
next:140595582998544
====================
id:140595582998544
data:0
next:140595582998608
====================
id:140595582998608
data:1
next:140595582998672
====================
id:140595582998672
data:2
next:140595582998736
====================
id:140595582998736
data:3
next:140595582998800
====================
id:140595582998800
data:4
next:9560016
def create5():
L = r = LNode()
L.next = L
for i in range(5):
p = LNode()
p.data = i
r.next = p
r = p
if L.next != L:
r.next = L
return L
print create5()
====================
id:140634482694032
data:None
next:140634482694160
====================
id:140634482694160
data:0
next:140634482694224
====================
id:140634482694224
data:1
next:140634482694288
====================
id:140634482694288
data:2
next:140634482694352
====================
id:140634482694352
data:3
next:140634482694416
====================
id:140634482694416
data:4
next:140634482694032
class DuLNode(object):
def __init__(self):
self._data = None
self._next = None
self._prior = None
@property
def data(self):
return self._data
@data.setter
def data(self, data):
self._data = data
@property
def next(self):
return self._next
@next.setter
def next(self, node):
assert (node is None or isinstance(node, DuLNode)), 'Type error'
self._next = node
@property
def prior(self):
return self._prior
@prior.setter
def prior(self, node):
assert (node is None or isinstance(node, DuLNode)), 'Type error'
self._prior = node
def __str__(self):
s = ""
ids = []
node = self
indent = ' '
i = 0
while node:
if id(node) in ids:
break
ids.append(id(node))
s += indent * i + "=" * 20 + '\n'
s += indent * i + "id:" + str(id(node)) + '\n'
if hasattr(node, 'prior'):
s += indent * i + "prior:" + str(id(node.prior)) + '\n'
s += indent * i + "data:" + str(node.data) + '\n'
s += indent * i + "next:" + str(id(node.next)) + '\n'
i += 1
node = node.next
return s
def create6():
L = r = DuLNode()
L.prior = L.next = None
for i in range(5):
p = DuLNode()
p.data = i
r.next = p
p.prior = r
r = p
if L.next != None:
r.next = None
return L
print create6()
====================
id:140473510295504
prior:9560016
data:None
next:140473510295632
====================
id:140473510295632
prior:140473510295504
data:0
next:140473510295696
====================
id:140473510295696
prior:140473510295632
data:1
next:140473510295760
====================
id:140473510295760
prior:140473510295696
data:2
next:140473510295824
====================
id:140473510295824
prior:140473510295760
data:3
next:140473510295888
====================
id:140473510295888
prior:140473510295824
data:4
next:9560016
class LNode(object):
def __init__(self):
self._data = None
self._next = None
self._prior = None
@property
def data(self):
return self._data
@data.setter
def data(self, data):
self._data = data
@property
def next(self):
return self._next
@next.setter
def next(self, node):
assert (node is None or isinstance(node, LNode)), 'Type error'
self._next = node
@property
def prior(self):
return self._prior
@prior.setter
def prior(self, node):
assert (node is None or isinstance(node, LNode)), 'Type error'
self._prior = node
class MyStack(object):
def __init__(self):
self.base = self.top = LNode()
def cleanStack(self):
last = self.top
while last and self.length():
remove_node = last
last = last.prior
last.next = None
del remove_node
def length(self):
length = 0
node = self.base
node = node.next
while node:
node = node.next
length += 1
return length
def getTop(self):
ret = None
if self.length():
ret = self.node.data
return ret
def push(self, data):
p = LNode()
p.data = data
p.prior = self.top
self.top.next = p
self.top = p
def pop(self):
ret = None
if self.length():
ret = self.top.data
remove = self.top.prior
self.top = self.top.prior
self.top.next = None
del remove
return ret
def __str__(self):
s = ""
ids = []
node = self.base
indent = ' '
i = 0
while node:
if id(node) in ids:
break
ids.append(id(node))
s += indent * i + "=" * 20 + '\n'
s += indent * i + "id:" + str(id(node)) + '\n'
if hasattr(node, 'prior'):
s += indent * i + "prior:" + str(id(node.prior)) + '\n'
s += indent * i + "data:" + str(node.data) + '\n'
s += indent * i + "next:" + str(id(node.next)) + '\n'
i += 1
node = node.next
return s
m = MyStack()
for i in range(3):
m.push(i)
print m
m.pop()
print m
m.cleanStack()
print m
[outputs]
====================
id:140116126312592
prior:9560016
data:None
next:140116088110352
====================
id:140116088110352
prior:140116126312592
data:0
next:140116083306000
====================
id:140116083306000
prior:140116088110352
data:1
next:140116083306064
====================
id:140116083306064
prior:140116083306000
data:2
next:9560016
====================
id:140116126312592
prior:9560016
data:None
next:140116088110352
====================
id:140116088110352
prior:140116126312592
data:0
next:140116083306000
====================
id:140116083306000
prior:140116088110352
data:1
next:9560016
====================
id:140116126312592
prior:9560016
data:None
next:9560016
class MyQueue(object):
def __init__(self):
self.front = self.rear = LNode()
self.rear.next = None
def length(self):
length = 0
node = self.front
node = node.next
while node:
node = node.next
length += 1
return length
def enQueue(self, data):
p = LNode()
p.data = data
self.rear.next = p
self.rear = p
def deQueue(self):
if self.front == self.rear:
return
p = self.front.next
ret = p.data
self.front.next = p.next
if self.rear == p:
self.rear = self.front
return ret
def destroyQueue(self):
if self.front == self.rear:
return
while self.length():
p = self.front.next
self.front.next = p.next
if self.rear == p:
self.rear = self.front
def __str__(self):
s = ""
ids = []
node = self.front
indent = ' '
i = 0
while node:
if id(node) in ids:
break
ids.append(id(node))
s += indent * i + "=" * 20 + '\n'
s += indent * i + "id:" + str(id(node)) + '\n'
s += indent * i + "data:" + str(node.data) + '\n'
s += indent * i + "next:" + str(id(node.next)) + '\n'
i += 1
node = node.next
return s
def example_MyQueue():
q = MyQueue()
for i in range(3):
q.enQueue(i)
print q
q.destroyQueue()
print q
for i in range(3):
q.enQueue(i)
print q
while q.length():
print q.deQueue()
print q
example_MyQueue()
====================
id:140478797636880
data:None
next:140478759423568
====================
id:140478759423568
data:0
next:140478754672464
====================
id:140478754672464
data:1
next:140478754672528
====================
id:140478754672528
data:2
next:9560016
====================
id:140478797636880
data:None
next:9560016
0
1
2
====================
id:140478797636880
data:None
next:9560016
class BiTNode(object):
def __init__(self):
self._data = None
self._left = None
self._right = None
@property
def data(self):
return self._data
@data.setter
def data(self, data):
self._data = data
@property
def left(self):
return self._next
@left.setter
def left(self, node):
assert (node is None or isinstance(node, BiTNode)), 'Type error'
self.left = node
@property
def right(self):
return self._right
@right.setter
def right(self, node):
assert (node is None or isinstance(node, BiTNode)), 'Type error'
self._right = node
class BiTNodeHelper(object):
def inorder(self, node):
if node is not None:
self.inorder(node.left)
print(node.data)
self.inorder(node.right)
def preorder(self, node):
if node is not None:
print(node.data)
self.preorder(node.left)
self.preorder(node.right)
def postorder(self, node):
if node is not None:
self.postorder(node.left)
self.postorder(node.right)
print(node.data)
tree = Node(1)
tree.left = Node(2)
tree.right = Node(3)
tree.left.left = Node(4)
tree.left.right = Node(5)
tree.right.left = Node(6)
tree.right.right = Node(7)
t = BiTNodeHelper()
print '=====preorder====='
t.preorder(tree)
print '=====inorder======'
t.inorder(tree)
print '=====postorder===='
t.postorder(tree)
outputs:
=====preorder=====
1
2
4
5
3
6
7
=====inorder======
4
2
5
1
6
3
7
=====postorder====
4
5
2
6
7
3
1
