def getinput(tinput,k):
size=len(tinput)
if size==0 or k>size:
return []
array=sort(tinput,size)
return array[:k]
def sort(array,size):
for i in range(int(size/2-1),-1,-1):
array=adjust(array,i,size-1)#
for j in range(size-1,-1,-1):
temp=array[j]
array[j]=array[0]
array[0]=temp
array=adjust(array,0,j-1)
return array
def adjust(array,start,end):
temp=array[start]
i=start*2+1
while i<=end:
if i+1<end and array[i+1]>array[i]:
i+=1
if array[i]<temp:
break
array[start]=temp
start=i
i=start*2+1
array[start]=temp
return array
选择排序
def choose_sort(r):
length=len(r)
for i in range(length):
minmum=i
for j in range(i+1,length):
if lis[minmum]>lis[j]:
minmum=j
if i!=minmum:
swap(i,minmum)
快速排序
def quicksort(r):
if (low<=high):
div=partion(r,0,len(r))
quicksort(r,0,div-1)
quicksort(r,div+1,len(r))
def partion(r,low,high):
lis=r
key=lis[low]
while low<high:
while low<high and lis[high]>=key:
hight-=1
swap(low,high)
while low<high and lis[low]<=key:
low+=1
swap(low,high)
return low
key=lis[low]
while low<high:
while low<high and lis[high]<key:
high-=1
swap(low,high)
while low<high and lis[low]>key:
low+=1
swap(low,high)
归并排序
def merge_sort(arr,temp,s,end):
temp=[None for i in range(len(arr))]
if s<end:
mid=int((s+end)/2)
merge_sort(arr,temp,s,mid)
merge_sort(arr,temp,mid+1,end)
merge(arr,temp,s,mid,end)
def merge(arr,temp,s,m,end):
i=s
j=m+1
t=0
while(i<=m and j<=end):
if arr[i]<=arr[j]:
temp[t]=arr[i]
i+=1
else:
temp[t]=arr[j]
j+=1
t+=1
while(i<=m):
temp[t]=arr[i]
t+=1
i+=1
while(j<=end):
temp[t]=arr[j]
t+=1
j+=1
t=0
while(s<=end):
arr[s]=temp[t]
s+=1
t+=1
def merge_sort(arr,temp,s,end):
temp=[None for i in range(len(arr))]
if s<end:
mid=int((s+end)/2)
merge_sort(arr,temp,s,mid)
merge_sort(arr,temp,mid+1,end)
merge(arr,temp,s,mid,end)
def merge(arr,temp,s,m,end):
i=s
j=m+1
t=0
while(i<=m and j<=end):
if arr[i]<=arr[j]:
temp[t]=arr[i]
i+=1
else:
temp[t]=arr[j]
j+=1
t+=1
while(i<=m):
temp[t]=arr[i]
t+=1
i+=1
while(j<=end):
temp[t]=arr[j]
t+=1
j+=1
t=0
while(s<=end):
arr[s]=temp[t]
s+=1
t+=1
import tensorflow as tf
class TextCnn:
def __init__(self,sequence_length,num_classes,embedding_size,filter_sizes,num_filters,l2_reg_lambda=0.0,attention_dim=100,use_attention=True):
self.embedded_chars=tf.placeholder(tf.float32,[None,sequence_length,embedding_size],name='embedded_chars')
self.input_y=tf.placeholder(tf.float32,[None,num_classes],name='input_y')
self.dropout_keep_prob=tf.placeholder(tf.float32,name='dropout_keep_prob')
self.sequence_length=sequence_length
self.embedding_size=embedding_size
l2_loss=tf.constant(0.0)
if use_attention:
self.attention_hidden_dim=attention_dim
self.attention_W=tf.Variable(tf.random_uniform([self.embedding_size,self.attention_hidden_dim],0.0,1.0),name='attention_W')
self.attention_U=tf.Variable(tf.random_uniform([self.embedding_size,self.attention_hidden_dim],0.0,1.0),name='attendion_U')
self.attention_V=tf.Variable(tf.random_uniform([self.attention_hidden_dim,1],0.0,1.0),name='attention_V')
self.output_att=list()
with tf.name_scope('attention'):
input_att=tf.split(self.embedded_chars,self.sequence_length,axis=1)
for index,x_i in enumerate(input_att):
x_i=tf.reshape(x_i,[-1,self.embedding_size])
c_i=self.attention(x_i,input_att,index)
inp=tf.concat([x_i,c_i],axis=1)
self.output_att.append(inp)
input_conv = tf.reshape(tf.concat(self.output_att,axis=1),[-1,self.sequence_length,self.embedding_size*2],name='input_convolution')
self.input_conv_expanded=tf.expand_dims(input_conv,-1)
else:
self.input_conv_expanded=tf.expand_dims(self.embedded_chars,-1)
dim_input_conv=self.input_conv_expanded.shape[-2].value
pooled_outputs=[]
for i,filter_size in enumerate(filter_sizes):
with tf.name_scope('conv-maxpool-%s'%filter_size):
filter_shape=[filter_size,dim_input_conv,1,num_filters]
W=tf.Variable(tf.truncated_normal(filter_shape,stddev=0.1),name='W')
b=tf.Variable(tf.constant(0.1,shape=[num_filters]),name='b')
conv=tf.nn.conv2d(self.input_conv_expanded,W,strides=[1,1,1,1])
padding=VALID
name='convolution')
h=tf.nn.relu(tf.nn.bias_add(conv,b),name='relu')
pooled=tf.nn.max_pool(h,ksize=[1,sequence_length-filter_size+1,1,1],strides=[1,1,1,1],padding='valid',name='pool')
pooled_outputs.append(pooled)
num_filters_total=num_filters*len(filter_sizes)
self.h_pool=tf.concat(pooled_outputs,3)
self.h_pool_flat=tf.reshape(self.h_pool,[-1,num_filters_total])
with tf.name_scope('dropout'):
self.h_drop=tf.nn.dropout(self.h_pool_flat,self.dropout_keep_prob)
with tf.name_scope('output')
W = tf.get_variable('W',shape=[num_filters_total,num_classes],initializer=tf.contrib.layers.xavier_initialzer())
b=tf.Variable(tf.constant(0.1,shape=[num_classes]),name='b')
l2_loss+=tf.nn.l2_loss(W)
l2_loss+=tf.nn.l2_loss(b)
self.scores=tf.nn.xw_plus_b(self.h_drop,W,b,name='scores')
self.predictions=tf.argmax(self.scores,1,name='predictions')
self.probabilities=tf.nn.sigmoid(self.scores,name='probabilities')
with tf.name_scope('loss):
losses=tf.nn.sigmoid_cross_entropy_with_logits(logits=self.scores,labels=self.input_y)
self.loss=tf.reduce_mean(losses)+l2_reg_lambda*l2_loss
with tf.name_scope('accuracy'):
correct_predictions=tf.equal(self.predictions,tf.argmax(self.input_y,1))
self.accuracy=tf.reduce_mean(tf.cast(correct_predictions,'flot'),name'accuracy')
def attention(self,x_i,x,index):
e_i=[]
c_i=[]
for output in x:
output=tf.reshape(output,[-1,self.embedding_size])
atten_hidden=tf.tanh(tf.add(tf.matmul(x_i,self.attention_W),tf.matmul(output,self.attention_U)))
e_i_j=tf.matmul(atten_hidden,self.attention_V)
e_i.append(e_i_j)
e_i=tf.concat(e_i,axis=1)
alpha_i=tf.nn.softmax(e_i)
alpha_i=tf.split(alpha_i,self.sequence_length,1)
for j,(alpha_i_j,output) in enumerate(zip(alpha_i,x):
if j==index:
continue
else:
output=tf.reshape(output,[-1,self.embedding_size])
c_i_j=tf.multiply(alpha_i_j,output)
c_i.append(c_i_j)
c_i=tf.reshape(tf.concat(c_i,axis=1),[-1,self.sequence_length-1,self.embedding_size])
c_i=tf.reduce_sum(c_i,1)
return c_i
#KMP
def getnextarray(t):
next=[-1,0]
for i in range(2,len(t)):
next.append(0)
for j in range(2,len(t)):
k=next[j-1]
while k!=-1:
if t[j-1]==t[k]:
next[j]=k+1
else:
k=next[k]
next[j]=0
return next
def kmpalg(s,t):
next=getnextarray(t)
i=0
j=0
while i<len(s) or j<len(t):
if j==-1 or s[i]==t[j]:
i+=1
j+=1
else:
j=next[j]
if j==len(t):
return i-j
else:
return -1
#计算base的exponent次方
def Power(self, base, exponent):
# write code here
if base==0:#若底为0，返回0
return 0
sum=1#注意要初始化一个存储计算结果的变量，不能直接对base进行叠乘，因为直接叠乘会改变base的大小
if exponent>0:#次方大于0，正常操作
for i in range(exponent):
sum=sum*base
return sum
elif exponent==0:#次数等于0，返回1
return 1
else:#次数小于0，先将次数取反，最后返回的是求完积之后的倒数
exponent=-(exponent)
for i in range(exponent):
sum=sum*base
return 1.0/sum
#调整数组顺序使奇数位于偶数前面
def reOrderArray(self, array):
# write code here
#ood,even=[],[]#新建两个列表，分别存储奇数、偶数
#
#for a in array:#数组可以通过循环依次得到各个元素
# if a%2==0:
# even.append(a)
# else:
# ood.append(a)
#return ood+even
for i in range(1,len(array)):
if (array[i]%2)!=0 and i!=0:
temp=array[i]
j=i-1
while j>=0 and (array[j]%2)==0:
array[j+1]=array[j]
j-=1
array[j+1]=temp
return array
#链表中倒数第k个节点
def FindKthToTail(self, head, k):
# write code here
#方法一：先遍历一遍得到链表长度，再遍历到第n-k+1个节点即为倒数第k个节点
#方法二：设置两个指针，一个先走k-1步，然后另一个指针开始走，两个始终相差k-1,直到前面的指针走到
#最后一个节点输出后面指针指向的节点
if head==None or k==0:
return None
else:
bef=head
for i in range(k-1):#注意先走k-1步，由于range从0开始，先走一步的时候要k-1!!!!!!!!
if bef.next!=None:
bef=bef.next
else:
return None
after=head
while bef.next!=None:
bef=bef.next
after=after.next
return after
def Merge(pHead1,pHead2):
dummy=ListNode(0)
pHead=dummy
while pHead1 and pHead2:
if pHead1.val>=pHead2.val:
dummy.next=pHead2
pHead2=pHead2.next
else:
dummy.next=pHead1
pHead1=pHead1.next
dummy=dummy.next
if pHead1:
dummy.next=pHead1
if pHead2:
dummy.next=pHead2
return pHead.next
def Merge(self, pHead1, pHead2):
# write code here
dummy = ListNode(0)
pHead = dummy
while pHead1 and pHead2:
if pHead1.val >= pHead2.val:
dummy.next = pHead2
pHead2 = pHead2.next
else:
dummy.next = pHead1
pHead1 = pHead1.next
dummy = dummy.next
if pHead1:
dummy.next = pHead1
if pHead2:
dummy.next = pHead2
return pHead.next
def Merge(self, pHead1, pHead2):
# write code here
ListNode mergenode=null
ListNode current=null
while pHead1!=null and pHead2!=null:
if pHead1.val<=pHead2.val:
if mergenode==null:
mergenode=current=pHead1
else:
current.next=pHead1
pHead1=pHead1.next
else:
if mergenode==null:
mergenode=current=pHead2
else:
current.next=pHead2
pHead2=pHead2.next
return mergenode
ListNode Merge(ListNode list1,ListNode list2):
if list1==None:
return list2
if list2==None:
return list1
if list1.val<list2.val:
res=list1
res.next=Merge(list1.next,list2)
elif list1.val>list2.val:
res=list2
res.next=Merge(list1,list2.next)
return res
def HasSubtree(proot1,proot2):
result=False
if proot1!=None and proot2!=None:
if proot1.val==proot2.val:
result=doestree(proot1,proot2)
if not result:
result=Has(proot1.left,proot2)
if not result:
result=Has(proot1.right,proot2)
def doestree(proot1,proot2):
if proot2==None:
return True
if proot1==None:
return False
if proot1.val!=proot2.val:
return False
return does()and does()
char *strcpy(char *strDes,const char *string)
{
if(string==NULL &&strDes==NULL)
{return NULL;
}
char* address=strDes
while(*string!='\0'){
*(strDes++)=*(string++);
}
*strDes='\0';
return address
}
#二叉搜索树的后序遍历序列
def VerifySquenceOfBST(self, sequence):
if sequence==None or len(sequence)==0:
return None
node=sequence[-1]
length=len(sequence)
for i in range(length):
if sequence[i]>node:
break
for j in range(i):
if sequence[j]>node:
return False
for j in range(i,length):
if sequence[j]<node:
return False
left=True
if i>0;
left=VerifySquenceOfBST(sequence[:i])
right=True
if i<length-1:
right=VerifySquenceOfBST(sequence[i:-1])
return left and right
def FindPathMain(root,path,currentSum):
currentSum+=root.val
path.append(root)
isLeaf=(root.left==None and root.right==None)
if currentSum==expectNumber and isLeaf:
onePath=[]
for node in path:
onePath.append(node.val)
result.append(onepath)
if currentSum<expectNumber:
if root.left:
FindPathMain(root.left,path,currentSum)
if root.right:
FindPathMain(root.right,path,currentSum)
path.pop()
def FindPathMain(root,path,currentSum):
currentSum+=root.val
path.append(root)
if currentSum==expect:
onepath=[]
for i in path:
onepath.append(i)
result.append(onePath)
elif currentSum<expect:
if root.left:
FindPathMain(root.left,path,currentSum)
if root.right:
FindPathMain(root.left,path,currentSum)
path.pop()
#字符串的排列
def Permutation(ss):
if not ss:#若为空
return []
res=[]
helper(ss,res,'')
return sorted(list(set(res)))
def helper(ss,res,path):
if not ss:#ss若为空，将得到的path存入结果res
res.append(path)
else:
for i in range(len(ss)):
helper(ss[:i]+ss[i+1:],res,path+ss[i])
#连续子数组的最大和
def FindGreatestSumOfSubArray(self, array):
# write code here
n = len(array)
dp = [ i for i in array]#dp存储历史上的和的最大值 先对dp初始化为数组元素
for i in range(1,n):
#不断对数组元素依次求和，遇到比前面的和更大的元素，更换max为该元素；否则一直求和，并记录每次求和结果
dp[i] = max(dp[i-1]+array[i],array[i])
return max(dp)#最后返回求和过程中的最大值
sum=array[0]
res=-0xffffffff
for i in range(1,len(array)):
sum=sum+array[i]
if sum<0:
if res<(sum-array[i]):
res=sum-array[i]
sum=0
else:
if sum>res:
res=sum
return res
max_sum = array[0]
pre_sum = 0
for i in array:
if pre_sum < 0:
pre_sum = i
else:
pre_sum += i
if pre_sum > max_sum:
max_sum = pre_sum
return max_sum
#丑数
def choushu(index):
ind=1
res=[1]
x=y=z=0
while ind<index:
minnum=min(2*res[x],3*res[y],5*res[z])
res.append(minnum)
if minnum<=2*res[x]:
x+=1
if minnum<=3*res[y]:
y+=1
if minnum<=5*res[z]:
z+=1
ind+=1
return minnum
#归并排序
def merge_sort(arr,temp,s,end):
temp=[None for i in range(len(arr))]
if s<end:
mid=(s+end)//2
merge_sort(arr,temp,s,mid)
merge_sort(arr,temp,mid+1,end)
merge(arr,temp,s,mid,end)
def merge(arr,temp,s,m,end):
i=s
j=m+1
t=0
while (i<=m and j<=end):
if arr[i]<arr[j]:
temp[t]=arr[i]
i+=1
else:
temp[t]=arr[j]
j+=1
t+=1
while i<=m:
temp[t]=arr[i]
i+=1
t+=1
while j<=end:
temp[t]=arr[j]
j+=1
t+=1
for i in range(end):
arr[i]=temp[i]
def FindFirstCommonNode(self, pHead1, pHead2):
# write code here
#两个链表第一个公共节点之后的节点都是重复的，
#所以从链尾开始查找，找到最后一个两个链表相同的节点
nodes=[]
while pHead1:
nodes.append(pHead1)
pHead1=pHead1.next
id=0
while pHead2:
if pHead2.val==nodes[id].val:
return pHead2
pHead2=pHead2.next
id+=1
def GetNumberOfK(self, data, k):
# write code here
if self.endk(data,k,0,len(data)-1)==-1:#表示data中没有k
return 0
else:
return self.endk(data,k,0,len(data)-1)-self.firstk(data,k,0,len(data)-1)+1
#注意最后要加1，才是k的个数
#下面两个函数 是一样的，只是一个找第一个一个找最后一个，其中的一些判断条件不同
#找到第一个k出现的位置
def firstk(self,data,k,first,end):
if first>end:#递归终止条件，返回-1
return -1
#二分查找
mid=int((first+end)/2)
middata=data[mid]
if middata==k:
if (mid>0 and data[mid-1]!=k)or mid==0:#若mid在大于0的时候对应的前一个位置的值不是k,或者此时mid=0
return mid#找到第一个位置的k
else:
end=mid-1
elif middata<k:
first=mid+1
elif middata>k:
end=mid-1
return self.firstk(data,k,first,end)#每次递归要传入查找的范围
#找到最后一个k出现的位置
def endk(self,data,k,first,end):
if first>end:
return -1
mid=int((first+end)/2)
middata=data[mid]
if middata==k:
if (mid+1<(len(data)) and data[mid+1]!=k)or mid==(len(data)-1):
return mid#找到第一个位置的k
else:
first=mid+1
elif middata<k:
first=mid+1
elif middata>k:
end=mid-1
return self.endk(data,k,first,end)
#把字符串转成整数
def str2num(s):
slist=['1','2','3','4','5','6','7','8','9','0']
fuhao=['-','+']
first=0
sum=0
direct=0#未被赋值，即没有符号
for i in s:
if i not in slist and i not in fuhao:
return 0
if first==0 and i in fuhao:#第一个位置
first=1
if i=='-':
direct=-1
else:
direct=1
else:
sum=sum*10+i
if direct==0:
direct=1
return direct*sum
def isNumeric(self, s):
'''
# write code here
length=len(s)
#需要判断的三种符号
hase=False
hasdot=False
hassigh=False
if length<=0:
return False
else:
for i in range(length):#对每个元素依次判断
if s[i]=='e' or s[i]=='E':
if hase:#若已经有了e或E则false
return False
else:#若之前没有，则记录为True
hase=True
if i==length-1:#e的位置不能是最后一个
return False
elif s[i]=='.':
if hasdot or hase:
return False
else:
hasdot=True#不能用==，之前用错了！！！！
if hase:#若已经有了e,后面不能有.
return False
elif s[i]=='+' or s[i]=='-':#+-可以出现在e后面,或者第一个位置（直接判断其位置不行吗？）
if hassigh:#注意！！！！！！！这个地方，判断条件是如果之前出现过+-
if s[i-1]!='e' and s[i-1]!='E':
return False
else:#没有e的话，+-只能出现在开头 注意！！这里判断的不是是否有e而是之前是否有符号位出现过
hassigh=True
if i!=0 and s[i-1]!='e' and s[i-1]!='E':#若+-不在第一个位置或者不在e后面
return False
elif s[i]<'0' or s[i]>'9':
return False
#不能在循环中返回，否则在判断第一个元素后就会返回，不再继续比较
#else:
#return True
return True
#序列化和反序列化二叉树
'''def Serialize(self, root):
self.s = ''
self.sarializeCore(root)
return self.s
def sarializeCore(self,root):
if root is None:
self.s += "#,"
return
self.s += str(root.val)+","
self.sarializeCore(root.left)
self.sarializeCore(root.right)
return self.s#这句没有也可
def Deserialize(self, s):
if s is None:
return None
if len(s)==1 and s[0]=="#":
return None
self.index = 0
s= s.split(',')
root = self.DeserializeCore(s)
return root
def DeserializeCore(self,s):
t = s[self.index]
if t.isdigit():
root = TreeNode(int(t))
self.index +=1
left = self.DeserializeCore(s)
right = self.DeserializeCore(s)
root.left = left
root.right = right
return root#这个地方必须有，没有就没构建出来节点
elif t =="#":
self.index+=1
return None
'''
def Serialize(self,root):
self.s=''
self.sarializeCore(root)
return self.s
def sarializeCore(self,root):
if root is None:
self.s+='#,'#注意要加逗号分隔
return self.s
self.s+=str(root.val)+','#注意要加逗号分隔,将数字转为str
self.sarializeCore(root.left)
self.sarializeCore(root.right)
def Deserialize(self,s):
if s is None:
return None
if len(s)==1 and s[0]=='#':
return None
self.index=0
s=s.split(',')
root=self.DeserializeCore(s)
return root
def DeserializeCore(self,s):
t=s[self.index]
if t.isdigit():
root=TreeNode(int(t))#注意转为int
self.index+=1
left=self.DeserializeCore(s)
right=self.DeserializeCore(s)
root.left=left
root.right=right
return root
elif t=='#':
self.index+=1
return None
#疯狂游戏笔试题：n个数之间的大于等于有多少种可能
#c语言代码
#include <stdio.h>
int main(){
int n;
while(scanf("%d",&n)!=EOF){
int i,j,count2[19],count[19]={0};
int sum=0;
count[1]=1;
count[2]=2;
for(i=3;i<=n;i++){
for(j=2;j<=i;j++){
count2[j]=(count[j]+count[j-1])*j;
}
for(j=2;j<=i;j++){
count[j]=count2[j];}
}
for(i=1;i<=n;i++){
sum+=count[i];
}
}
return 0;
}
#堆排序
def msort():
array=[1,2,3,4]
size=len(array)
array=sort(array,size)
return array
def sort(array,size):
for i in range(int(size/2)-1,-1,-1):
adjust(array,i,size-1)
for i in range(size-1,-1,-1):
temp=array[0]
array[0]=array[i]
array[i]=temp
adjust(array,0,i-1)
def adjust(array,start,end):
temp=array[start]
i=2*start+1
while i<=end:
if i+1<=end and array[i+1]<array[i]:
i=i+1#注意要初始化一个存储计算结果的变量，不能直接对base进行叠乘，因为直接叠乘会改变base的大小
if array[i]>temp:
break
array[start]=array[i]
start=i
i=2*start+1
array[start]=temp
#快排
def sort():
lis=[1,2,3,4]
qsort(lis,0,len(lis)-1)
def qsort(lis,low,high):
if low<high:
key=partion(lis,low,high)
qsort(lis,low,key-1)
qsort(lis,key+1,high)
def partion(lis,low,high):
keynum=lis[low]
while low<high:
while low<high and lis[high]>=keynum:
high-=1
swap(lis[high],lis[low])
while low <high and lis[low]<=keynum:
low+=1#注意要初始化一个存储计算结果的变量，不能直接对base进行叠乘，因为直接叠乘会改变base的大小
swap()
return low
#字符串的排列
def code27(s):
if len(s)==1:
return s[1]
res=[]
for i in range(len(s)):
l=code27(s[:i]+s[i+1:])
for m in l:
res.append(s[i]+m)
return res
def permutation(s):
word=list(s)
return list(sorted(set(code27(word))))
#归并排序
def merge_sort(arr,temp,s,end):
temp=[None for in in range(len(arr))]
if s<end:
mid=int((s+end)/2)
merge_sort(arr,temp,s,mid)#先分割
merge_sort(arr,temp,mid+1,end)
merge(arr,temp,s,mid,end)#然后合并
return arr
def merge(arr,temp,s,mid,end):
t=0#未被赋值，即没有符号
i=s
j=mid+1
while i<=mid and j<=end:
if arr[i]<arr[j]:
temp[t]=arr[i]
i+=1
else:
temp[t]=arr[j]
j+=1
t+=1
while i<mid:
temp[t]=arr[i]
t+=1
i+=1
while j<end:
temp[t]=arr[j]
t+=1
j+=1
t=0
while(s<=end):
arr[s]=temp[t]
s+=1#注意要初始化一个存储计算结果的变量，不能直接对base进行叠乘，因为直接叠乘会改变base的大小
t+=1
#堆排序
def sort(data):
size=len(data)
for i in range(size//2-1,-1,-1):
adjust(data,i,size-1)
for i in range(size-1,-1,-1):
temp=data[0]
data[0]=data[i]
data[i]=temp
adjust(data,0,i-1)
def adjust(data,start,end):
temp=data[start]
i=start*2+1#注意要初始化一个存储计算结果的变量，不能直接对base进行叠乘，因为直接叠乘会改变base的大小
while i<=end:
if i+1<=end and data[i+1]<data[i]:
i=i+1
if data[i]>temp:
break
data[start]=data[i]
start=i
i=start*2+1
data[start]=temp
#快速排序
def quiksort(data,low,high):
if low<high:
key=choose(data,low,high)
quiksort(data,low,key)
quiksort(data,key+1,high)
def choose(data,low,high):
keyvalue=data[low]
while low<high:
while low<high and data[high]>=keyvalue:
high-=1#注意要初始化一个存储计算结果的变量，不能直接对base进行叠乘，因为直接叠乘会改变base的大小
temp=data[low]
data[low]=data[high]
data[high]=temp
while low<high and data[low]<=keyvalue:
low+=1
temp=data[low]
data[low]=data[high]
data[high]=temp
return low
#快排
def sort(data,low,high):
if low<high:
key=qsort(data,low,high)
sort(data,low,key)
sort(data,key+1,high)
def qsort(data,low,high):
i=low
key=data[low]
while low<high:
while low<high and data[high]>=key:
high-=1#注意要初始化一个存储计算结果的变量，不能直接对base进行叠乘，因为直接叠乘会改变base的大小
swap()
while low<high and data[low]<=key:
low+=1
swap()
return low
#归并排序
def `msort(data,low,high):
temp=[None for i in range(len(data)]
if low<high:
mid=(low+high)//2
msort(data,low,mid)
msort(data,mid+1,high)
merge(data,temp,low,mid,high)
def merge(data,temp,low,mid,high):
i=low
j=mid+1
t=0
while i<=mid and j<=high
if data[i]<=data[j]:
temp[t]=data[i]
t+=1#注意要初始化一个存储计算结果的变量，不能直接对base进行叠乘，因为直接叠乘会改变base的大小
i+=1
else:
temp[t]=data[j]
t+=1
j+=1
while i<=mid:
temp[t]=data[i]
t+=1
i+=1#注意要初始化一个存储计算结果的变量，不能直接对base进行叠乘，因为直接叠乘会改变base的大小
while j<=high:
temp[t]=data[j]
t+=1
j+=1
t=0
while s<=high:
data[s]=temp[t]
s+=1
t+=1
#堆排序
def duisort(data):
for i in range(len(data)//2+1,-1,-1):
adjust(data,i,len(data)-1)
for i in range(len(data)-1,-1,-1):
temp=data[0]
data[0]=data[j]
data[j]=temp
adjust(data,0,j-1)
def adjust(data,s,end):
temp=data[s]
i=s*2+1
while i<=end:
if i+1<end and data[i+1]<data[i]:
i+=1
if data[i]>temp:
break
data[s]=data[i]
s=i
i=s*2+1
data[s]=temp
