单链表
class SingleNode ( object ) :
"""单个的节点"""
def __init__ ( self, item) :
self. item = item
self. next = None
class SingleLinkList ( object ) :
"""单链表"""
def __init__ ( self, node= None ) :
self. __head = node
def is_empty ( self) :
"""判断链表是否为空"""
if self. __head == None :
return True
else :
return False
def length ( self) :
"""链表长度"""
cur = self. __head
count = 0
while cur != None :
count += 1
cur = cur. next
return count
def travel ( self) :
"""遍历整个链表"""
cur = self. __head
while cur != None :
print ( cur. item, end= ' ' )
cur = cur. next
print ( "" )
def append ( self, item) :
"""链表尾部添加元素"""
node = SingleNode( item)
if self. is_empty( ) :
self. __head = node
else :
cur = self. __head
while cur. next != None :
cur = cur. next
cur. next = node
def add ( self, item) :
"""链表头部添加元素"""
node = SingleNode( item)
node. next = self. __head
self. __head = node
def insert ( self, pos, item) :
"""指定位置添加元素"""
if pos <= 0 :
self. add( item)
elif pos > self. length( ) - 1 :
self. append( item)
else :
node = SingleNode( item)
pre = self. __head
count = 0
while count < ( pos - 1 ) :
count += 1
pre = pre. next
node. next = pre. next
pre. next = node
def remove ( self, item) :
"""删除节点"""
cur = self. __head
pre = None
while cur != None :
if cur. item == item:
if cur == self. __head:
self. __head = cur. next
else :
pre. next = cur. next
break
else :
pre = cur
cur = cur. next
def search ( self, item) :
"""查找节点是否存在"""
cur = self. __head
while cur != None :
if cur. item == item:
return True
else :
cur = cur. next
return False
s = SingleLinkList( )
"""测试结果"""
print ( s. is_empty( ) )
print ( s. length( ) )
s. append( 10 )
s. append( 23 )
s. append( 13 )
s. append( 5 )
s. append( 34 )
print ( s. is_empty( ) )
print ( s. length( ) )
s. travel( )
s. insert( - 1 , 6 )
s. insert( 10 , 77 )
s. insert( 2 , 11 )
s. insert( 1 , 33 )
s. travel( )
print ( s. search( 77 ) )
s. remove( 33 )
s. travel( )
单向循环链表
class Node ( object ) :
"""节点"""
def __init__ ( self, item) :
self. item = item
self. next = None
class SinCycLinkList ( object ) :
"""单项循环链表"""
def __init__ ( self, node= None ) :
self. __head = None
if node:
node. next = node
def is_empty ( self) :
"""判断链表是否为空"""
if self. __head == None :
return True
else :
return False
def length ( self) :
"""返回链表的长度"""
if self. is_empty( ) :
return 0
cur = self. __head
count = 1
while cur. next != self. __head:
count += 1
cur = cur. next
return count
def travel ( self) :
"""遍历"""
if self. is_empty( ) :
return None
cur = self. __head
while cur. next != self. __head:
print ( cur. item, end= ' ' )
cur = cur. next
print ( cur. item)
def add ( self, item) :
"""链表头部添加元素"""
node = Node( item)
if self. is_empty( ) :
self. __head = node
node. next = self. __head
else :
cur = self. __head
while cur. next != self. __head:
cur = cur. next
node. next = self. __head
self. __head = node
cur. next = node
def append ( self, item) :
"""链表尾部添加元素"""
node = Node( item)
if self. is_empty( ) :
self. __head = node
node. next = self. __head
else :
cur = self. __head
while cur. next != self. __head:
cur = cur. next
cur. next = node
node. next = self. __head
def insert ( self, pos, item) :
"""指定位置添加元素"""
if pos <= 0 :
self. add( item)
elif pos > self. length( ) - 1 :
self. append( item)
else :
node = Node( item)
cur = self. __head
count = 0
while count < ( pos - 1 ) :
count += 1
cur = cur. next
node. next = cur. next
cur. next = node
def search ( self, item) :
"""查找节点是否存在"""
if self. is_empty( ) :
return False
cur = self. __head
while cur. next != self. __head:
if cur. item == item:
return True
else :
cur = cur. next
if cur. item == item:
return True
return False
def remove ( self, item) :
"""删除节点"""
if self. is_empty( ) :
return
cur = self. __head
pre = None
if cur. item == item:
if cur. next != self. __head:
while cur. next != self. __head:
cur = cur. next
cur. next = self. __head. next
self. __head = cur. next
else :
self. __head = None
else :
while cur. next != self. __head:
if cur. item == item:
pre. next = cur. next
return
else :
pre = cur
cur = cur. next
if cur. item == item:
pre. next = cur. next
s = SinCycLinkList( )
"""测试结果"""
print ( s. is_empty( ) )
print ( s. length( ) )
s. add( 1 )
s. add( 2 )
s. add( 3 )
s. add( 4 )
s. append( 6 )
s. append( 8 )
s. travel( )
s. insert( 2 , 7 )
s. insert( 2 , 7 )
s. travel( )
s. remove( 6 )
s. remove( 7 )
s. travel( )
双向链表
class Node ( object ) :
"""节点"""
def __init__ ( self, item) :
self. item = item
self. next = None
self. prev = None
class DoubleLinkList ( object ) :
"""双向链表"""
def __init__ ( self, node= None ) :
self. __head = node
def is_empty ( self) :
"""判断链表是否为空"""
if self. __head == None :
return True
else :
return False
def length ( self) :
"""返回链表的长度"""
if self. is_empty( ) :
return 0
cur = self. __head
count = 0
while cur != None :
count += 1
cur = cur. next
return count
def travel ( self) :
"""遍历"""
if self. is_empty( ) :
return None
cur = self. __head
while cur != None :
print ( cur. item, end= ' ' )
cur = cur. next
print ( "" )
def add ( self, item) :
"""链表头部添加元素"""
node = Node( item)
if self. is_empty( ) :
self. __head = node
else :
node. next = self. __head
self. __head. prev = node
self. __head = node
def append ( self, item) :
"""链表尾部添加元素"""
node = Node( item)
if self. is_empty( ) :
self. __head = node
else :
cur = self. __head
while cur. next != None :
cur = cur. next
cur. next = node
node. prev = cur
def insert ( self, pos, item) :
"""指定位置添加元素"""
if pos <= 0 :
self. add( item)
elif pos > self. length( ) - 1 :
self. append( item)
else :
node = Node( item)
cur = self. __head
count = 0
while count < ( pos - 1 ) :
count += 1
cur = cur. next
node. prev = cur
node. next = cur. next
cur. next . prev = node
cur. next = node
def search ( self, item) :
"""查找节点是否存在"""
cur = self. __head
while cur != None :
if cur. item == item:
return True
else :
cur = cur. next
return False
def remove ( self, item) :
"""删除节点"""
if self. is_empty( ) :
return
else :
cur = self. __head
if cur. item == item:
print ( 1 )
if cur. next == None :
self. __head = None
else :
cur. next . prev = None
self. __head = cur. next
return
while cur != None :
if cur. item == item:
print ( 2 )
cur. prev. next = cur. next
if cur. next :
cur. next . prev = cur. prev
break
cur = cur. next
d = DoubleLinkList( )
"""测试结果"""
print ( d. is_empty( ) )
print ( d. length( ) )
d. add( 1 )
d. add( 2 )
d. add( 3 )
d. append( 4 )
d. append( 10 )
d. travel( )
d. insert( - 1 , 0 )
d. insert( - 5 , 0 )
d. travel( )
栈
class Stack ( object ) :
"""用列表的方式来实现栈"""
def __init__ ( self) :
self. __items = [ ]
def is_empty ( self) :
"""判断栈是否为空"""
if self. __items == [ ] :
return True
else :
return False
def push ( self, item) :
"""添加一个新的元素item到栈顶"""
self. __items. append( item)
def pop ( self) :
"""弹出栈顶元素"""
return self. __items. pop( )
def peek ( self) :
"""返回栈顶元素"""
if self. is_empty( ) :
return None
else :
return self. __items[ - 1 ]
def size ( self) :
"""返回栈的元素个数"""
return len ( self. __items)
def travel ( self) :
"""遍历"""
print ( self. __items)
s = Stack( )
"""测试结果"""
print ( s. is_empty( ) )
s. push( 1 )
s. push( 2 )
s. push( 3 )
s. pop( )
s. travel( )
print ( s. size( ) )
print ( s. is_empty( ) )
print ( s. peek( ) )
s. travel( )
队列
class Queue ( object ) :
def __init__ ( self) :
self. __items = [ ]
def enqueue ( self, item) :
self. __items. append( item)
def dequeue ( self) :
"""
从队列头部删除一个元素
:return: 队列头元素
"""
return self. __items. pop( 0 )
def is_empty ( self) :
"""
判断一个队列是否为空
:return: True or False
"""
return self. __items == [ ]
def size ( self) :
return len ( self. __items)
def travel ( self) :
"""遍历"""
for item in self. __items:
print ( item, end= ' ' )
print ( '' )
q = Queue( )
"""测试结果"""
print ( q. is_empty( ) )
q. enqueue( 1 )
q. enqueue( 2 )
q. enqueue( 3 )
q. enqueue( 4 )
q. travel( )
q. dequeue( )
q. travel( )
冒泡排序
def bu_sort ( lis) :
n = len ( lis)
for j in range ( n- 1 ) :
for i in range ( 0 , n- 1 - j) :
if lis[ i] > lis[ i + 1 ] :
lis[ i] , lis[ i + 1 ] = lis[ i + 1 ] , lis[ i]
选择排序
"""
首先在未排序列中找到最小元素
放到已排序列的起始位置
然后从未排序列中继续寻找最小元素
添加到已排序列的末尾
以此类推,直到所有元素均排序完毕。
"""
def selection_sort ( lis) :
n = len ( lis)
for i in range ( n- 1 ) :
min_index = i
for j in range ( min_index, n) :
if lis[ j] < lis[ min_index] :
min_index = j
lis[ i] , lis[ min_index] = lis[ min_index] , lis[ i]
插入排序
"""
首先将数组中的数据分为两个区间
已排序区间和未排序区间
初始已排序区间只有一个元素
就是数组的第一个元素
插入排序的核心思想是取未排序区间中的元素
在已排序区间中找到合适的插入位置将其插入
并保证已排序区间数据一直有序
重复这个过程,直到未排序区间中元素为空,算法结束
"""
def insert_sort ( lis) :
n = len ( lis)
for i in range ( 1 , n) :
for j in range ( i, 0 , - 1 ) :
if lis[ j] < lis[ j - 1 ] :
lis[ j] , lis[ j - 1 ] = lis[ j - 1 ] , lis[ j]
希尔排序
def shell_sort ( lis) :
n = len ( lis)
gap = n// 2
while gap > 0 :
for i in range ( gap, n) :
while i >= gap and lis[ i- gap] > lis[ i] :
lis[ i- gap] , lis[ i] = lis[ i] , lis[ i- gap]
i -= gap
gap = gap// 2
快速排序
def quick_sort ( lis, start, end) :
if start >= end:
return
mid = lis[ start]
low = start
high = end
while low < high:
while low < high and lis[ high] >= mid:
high -= 1
lis[ low] = lis[ high]
while low < high and lis[ low] < mid:
low += 1
lis[ high] = lis[ low]
lis[ low] = mid
quick_sort( lis, start, low- 1 )
quick_sort( lis, low+ 1 , end)
lis = [ 9 , 21 , 43 , 27 , 67 , 31 , 49 , 55 , 20 ]
quick_sort( lis, 0 , len ( lis) - 1 )
归并排序
"""
将数组分解最小之后合并两个有序数组
基本思路是比较两个数组的最前面的数
谁小就先取谁,取了后相应的指针就往后移一位
然后再比较,直至一个数组为空,最后把另一个数组的剩余部分复制过来即可。
"""
def merge_sort ( lis) :
if len ( lis) <= 1 :
return lis
mid_index = len ( lis) // 2
left_lis = merge_sort( lis[ : mid_index] )
right_lis = merge_sort( lis[ mid_index: ] )
l_index = 0
r_index = 0
result = [ ]
while l_index < len ( left_lis) and r_index < len ( right_lis) :
if left_lis[ l_index] < right_lis[ r_index] :
result. append( left_lis[ l_index] )
l_index += 1
else :
result. append( right_lis[ r_index] )
r_index += 1
result += left_lis[ l_index: ]
result += right_lis[ r_index: ]
return result
lis = [ 14 , 26 , 63 , 17 , 77 , 31 , 44 , 55 , 20 ]
s = merge_sort( lis)