时间复杂度，枚举法
for a in range(0,101):
for b in range(0,101):
c=100-a-b
if a**2+b**2==c**2:
print(a,b,c)
1.线性表
1.1 顺序表，存储空间连续
1.2 单链表，数据区+链接区
# coding=utf-8
class Node(object):
def __init__(self,elem):
self.elem=elem
self.next=None
class SingleLinkList(object):
def __init__(self,node=None):
self._head =node
def is_empty(self):
return self._head ==None
def length(self):
# cur游标移动遍历节点
cur=self._head
# count记录数量
count=0
while cur !=None:
count +=1
cur=cur.next
return count
#遍历
def travel(self):
# cur游标移动遍历节点
cur=self._head
while cur !=None:
print(cur.elem)
cur=cur.next
#头插
def add(self,item):
node=Node(item)
node.next=self._head()
self._head=node
#尾插
def append(self,item):
node=Node(item)
if self.is_empty():
self._head=node
cur=self._head
while cur.next!=None:
cur=cur.next
cur.next=node
#插入
def insert(self,pos,item):
if pos<=0:
self.add(item)
elif pos>(self.length()-1):
self.append(item)
else:
pre= self._head()
count=0
while count < (pos-1):
count+=1
pre=pre.next
node=Node(item)
node.next=pre.next
pre.next=node
#删除
def remove(self,pos,item):
cur=self._head
pre=None
while cur!=None:
if cur.elem==item:
#先判断是否为头节点
if cur=self._head():
self._head()=cur.next
else:
pre.next=cur.next
else:
pre=cur
cur=cur.next
#查找
def search(self,item):
cur =self._head
while cur != None:
cur.elem=item:
return True
else:
cur=cur.next
return False
if __name__=="__main__":
ll=SingleLinkList()
print(ll.is_empty())
print(ll.length())
ll.append(1)
print(ll.is_empty())
print(ll.length())
1.3 双向链表
1.4 单向循环链表
2.栈和队列（双端队列）
3.排序算法
3.1 排序算法的稳定性
3.2冒泡排序 bubble_sort：
稳定
相邻的两个元素进行比较，然后把较大的元素放到后面（正向排序），在一轮比较完后最大的元素就放在了最后一个位置，因为这一点像鱼儿在水中吐的气泡在上升的过程中不断变大，所以得名冒泡排序。在该排序算法中，要遍历n-1轮，每一轮都要比较数组中的元素，所以时间复杂度是O(n2)。
def bubble_sort(list1):
count=len(list1)
for i in range(count-1):
for j in range(count-i-1):
if list1[j]>list1[j+1]:
list1[j],list1[j+1]=list1[j+1],list1[j]
return list1
blist = bubble_sort([4,5,6,7,3,2,6,9,8])
print (blist)
3.3 选择排序 select_sort：
不稳定
第1趟，在待排序记录r1- r[n]中选出最小的记录，将它与r1交换；第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；以此类推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使序列不断增长直到全部排序完毕
def select_sort(list1):
count=len(list1)
for i in range(0,count-1):
for j in range(i+1,count):
if list1[j]
list1[i],list1[j]=list1[j],list1[i]
return list1
blist =select_sort([1,5,6,7,3,2,6,9,8])
print (blist)
3.4插入排序 insert_sort：
稳定
通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入
def insert_sort(slist):
for i in range(1,len(slist)):
while i>0:
if slist[i] < slist[i-1]:
slist[i],slist[i-1]=slist[i-1],slist[i]
i-=1
else:
break
return slist
slist = select_sort([4,5,6,7,3,2,6,9,8])
print (slist)
3.5 希尔排序 shell_sort:
不稳定
把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止
def shell_sort(slist):
n=len(slist)
gap=n//2
while gap>0:
for j in range(gap,n):
i=j
while i>0:
if slist[i-gap]>slist[i]:
slist[i-gap],slist[i]= slist[i],slist[i-gap]
i-=gap
else:
break
gap //=2
return slist
slist =shell_sort([1,4,5,6,7,3,2,6,9,8,11,19])
print (slist)
3.6 快速排序 quick_sort（最重要）:
不稳定
快速排序适用于数据杂乱无章的场景，而且越乱，快速排序的效率越体现的淋漓尽致
def quick_sort(slist,first,last):
if first>=last:
return None
mid_value=slist[first]
low=first
high=last
while low
while low=mid_value:
high-=1
slist[high]= slist[low]
low+=1
while low
low+=1
slist[low]= slist[high]
high-=1
slist[low]=mid_value
quick_sort(slist,first,low-1)
quick_sort(slist,low+1,last)
return slist
slist=[1,4,5,6,7,3,2,6,9,8,11,19]
quick_sort(slist,0,len(slist)-1)
print(slist)
首先在这个序列中随便找一个数作为基准数，然后将这个序列中所有比基准数大的数放在该数字的右边，比基准数小的数放在该数字的左边。第一轮排序结束之后，再分别对已经好的基准书左边（比基准数小）和基准书右边（比基准书大）的数字序列重复上述操作，用递归形式即可实现快速排序，完成对整个序列的排序
#递归快排
def quick_sort(slist):
if len(slist)<2:
return slist
else:
basevalue=slist[0]
less=[l for l in slist if l
equal=[e for e in slist if e ==basevalue]
more=[m for m in slist if m>basevalue]
return quick_sort(less)+equal+quick_sort(more)
slist = quick_sort([4,5,6,7,3,2,6,9,8,11,19])
print (slist)
3.7 归并排序 merge_sort:
稳定
def merge_sort(slist):
n=len(slist)
if n<=1:
return slist
mid=n//2
#切片返回新的列表，与原表没有联系
left_li=merge_sort(slist[:mid])
right_li=merge_sort(slist[mid:])
leftpointer,rightpointer=0,0
result=[]
while leftpointer
if left_li[leftpointer]
result.append(left_li[leftpointer])
leftpointer+=1
else:
result.append(right_li[rightpointer])
rightpointer+=1
result+=left_li[leftpointer:]
result+=right_li[rightpointer:]
return result
slist=[1,4,5,6,7,3,2,6,9,8,11,19]
merge_sort(slist)
print(slist)八大排序算法时间空间复杂度分析_技术交流_牛客网www.nowcoder.com
4. 二分查找
操作对象只能是顺序表
时间复杂度：O(logn)
def binary_search(num_list,x):
num_list=sorted(num_list)
left,right=0,len(num_list)
while left
mid=(left+right)//2
if num_list[mid]>x:
right=mid
elif num_list[mid]
left=mid+1
else:
return num_list[mid]
return x
5. 树
5.1 二叉树
平衡二叉树：任何一颗节点的子树高度差不超过1
如何由（前中后）遍历确定一棵树
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
