11.22
直接用 feature engineer + 防过拟合的模型暴力破解真的是。。。。太强了。。。。囧
11.10
迷茫的时候，看不清楚路的时候，不应当更着急的向前探寻新的路，相反更应该沉下心来，去看看踩过的脚印厚不厚实，毕竟欠的债迟早是要还的。
总是给自己留下一个个虚浮的脚印，根基永远不稳，做事永远只做的差不多，不管做什么都是一半一半，刚刚好，那么就得做好你的人生也是刚刚好的准备！
10.10
windows 是这个世界最不友好的开发环境....没有之一.....太坑爹了,做什么都蛋疼的要屎....
5.22
为了参加天池第二赛季，特地学了hadoop的mapreduce，配置hadoop的过程简直吐血，搞了2天都快怀疑自己的智商了。。。虽然网上教程很多，但是总有些地方写的不清不楚，而且很多还都过时了，hadoop都出了2.X了，网上还都是1.X，0.X的更新，这简直不能忍。。hadoop实战这本书则写的更简略。。。sigh，过几天自己一定写一个造福广大小白群众！
4.18
天池的比赛终于开始了，最近看了不少东西，尤其是去年天池阿里比赛的资料，简直震惊了，很多以前想都没想到的东西，尤其是特征选择，简直集人类智慧之精华 =_=，各种想不到的特征点，感觉自己还是too young，看完之后受益良多，再回到自己参加的这次菜鸟网络的比赛，根据去年的比赛情况来看，这次的比赛应该主要还是2类模型的竞争了。一类是时间序列ARMA为主的动态模型，一类是静态模型如随即森林/GBDT为主的集合模型。当然还有第三种，也是我接下来想走的分析之路，嘿嘿，先不剧透了，兴许还要靠这个冲冠呢，哈哈，白日梦啊白日梦
3.21
这几天主要是跟小伙伴们报名参加了天池的比赛，想好好准备拿个好名次，然后在尝试着在linux系统下编程，慢慢适用，毕竟现在这个太重要了！
3.2
开学2周了，做了不少事，在家跟在学校完全是两种状态。。实习完成了一个小项目，故障诊断和预测的，果然有项目学起来快，python数据分析的基本操作大致上都掌握了，接下来要做新的项目了。等再过一些时间，开始好好准备下简历，投一投暑期实习！
PS：最近看了操作系统的书，对硬件跟内核有了一点了解，越看心越痒。。好想自己配一台主机。。。尤其是之前实习做的项目数据量有1G多，做个随机森林简直卡的不行，该换台好电脑了，哈哈，过段时间就配台超级台式机！！！
2.20
开学了，放假一个多月，在家啥都没干，囧，家里果然不是一个学习的地方，感觉有点颓。。这几天要好好调整下状态，加油，不能在这时停下脚步！
12.20
在诸多因素之下，我开始学Java了。我将来想做数据挖掘，但是要做数据挖掘，强大的编程能力、算法实现能力是必要的，在这方面，作为弱类型语言的python因为省略了太多，无法一窥内部具体实现，再加上hadoop等一些大数据软件都是基于Java的，所以有必要提高下Java编程能力了。
最近在看疯狂Java讲义，觉得规则清晰的强类型语言确实让人脑子变得很清楚，果然感觉还是强类型的适合开发啊，弱类型的在开发的时候虽然快速，但是后期很容易就会因为难以维护，导致性能越来越底下，这个时候强类型语言就显现出了巨大的优势。
也终于第一次知道了内存管理机制，我果然还是喜欢看这种带原理的书，python的书基本从来不讲内存管理机制，总会遇到一些莫名其妙的bug，可是看了Java的才发现，Python的内存管理机制估摸着跟Java应该是差不多的。。有些bug瞬间就懂了。
代码果然应该是这样的，知其然，知其所以然！
12.12 思考
我的课题是跟图像处理相关的东东，最近在看图像处理，突然想到一个想法，我们在储存图像和显示图像的时候，都是基于抽象数据，也就是他的RGB值来的，所以在图像识别的时候，我们还要特地将这种抽象数据识别成一种带有某种特征的“对象”，那如果从一开始我们在储存图像的时候，就让图像以对象的形式存储，结果会怎么用呢？例如一张风景照，我们定义里面的树，天空，草地，那是不是在后期的识别中，可以起到一个很好的作用？
脑洞了一下，不知道可不可行，啊哈
12.1 偶尔一个小算法
惰性学习算法之KNN的R语言实现(2)——完善版
#加入了剪辑近邻法，和随机生成数据的函数
<span style="font-size:14px;">#KNN自写版本
#以下数据的保存格式默认为最后一列为分类的类别。如果不是需要自己人为的先改变下数据的结构
#将数据随机分组3组，第一组有row1个数据，第二组有row2个，第三组row3个
#该函数要嘛产生两个随机数组要嘛产生三个
randomsample<-function(data,row1=0,row2=0,row3=0){
rows=nrow(data)
RandomNum=sample(1:rows,rows,replace=FALSE)
if ((row1+row2+row3)<=rows){
if(row3==0 & row2==0){
data1row=RandomNum[1:row1]
data1row=data1row[order(data1row)]
data1=data[data1row,]
return (data1)
}
else if(row3==0){
data1row=RandomNum[1:row1]
data2row=RandomNum[(row1+1):(row1+row2)]
data1row=data1row[order(data1row)]
data2row=data2row[order(data2row)]
data1=data[data1row,]
data2=data[data2row,]
result=list(data1=data1,data2=data2)
return (result)
}
else if (row1==0){
print('you must be kidding me...')
}
else{
data1row=RandomNum[1:row1]
data2row=RandomNum[(row1+1):(row1+row2)]
data3row=RandomNum[(row1+row2+1):(row1+row2+row3)]
data1row=data1row[order(data1row)]
data2row=data2row[order(data2row)]
data3row=data3row[order(data3row)]
data1=data[data1row,]
data2=data[data2row,]
data3=data[data3row,]
result=list(data1=data1,data2=data2,data3=data3)
return (result)
}
}
else{
print('rows out of bound')
return
}
}
result=randomsample(iris,50,20)
#传入要分类的单个向量，邻居的个数k，已知道所属类的数据集，最后返回其最大可能的类
classify<-function(vector,ClassifyData,k=5){
require(reshape2)
cols=ncol(ClassifyData)
data=ClassifyData[,1:cols-1]
alldistance=numeric(0)
for (i in 1:nrow(data)){
distance=sum((vector-data[i,])^2)
alldistance=c(alldistance,distance)
}
#以距离的倒数为权重
alldistance=data.frame(weight=1/alldistance,sequence=1:nrow(data),class=ClassifyData[,cols])
alldistance=alldistance[order(alldistance$weight),]
kNearest=tail(alldistance,k) #得到权重最高的几个值
m=melt(kNearest,id=c('class')) #用melt和cast计算各个类别的权重和
c=cast(m,class~variable,sum)
temp=c[order(c$weight,decreasing=TRUE),]
sortvector=cbind(vector,temp[1,1])
return (sortvector)
}
#对未分类的数据集进行分类，注意未分类的数据比已分类的数据少一列，那一列就是他们所属的类别
#最后返回的数据集加上我们对其的预测列
MyKNN<-function(UnClassifyData,ClassifyData,k=5){
rows_uns=nrow(UnClassifyData)
cols_s=ncol(ClassifyData)
result=as.data.frame(matrix(numeric(0),ncol=cols_s))
colnames(result)=colnames(ClassifyData)
for (i in 1:rows_uns){ #对数据集的每个数据进行分类
vect=classify(UnClassifyData[i,],ClassifyData,k=5)
result=rbind(result,vect)
}
colnames(result)=colnames(ClassifyData)
return (result)
}
#剪辑近邻法,得到剪辑后的数据集
#默认其分类值Y都存在最后一列
cutsample<-function(ReferenceData,TestData,k=1){
cols=ncol(TestData)
rows=nrow(TestData)
TestY=TestData[,cols]
TestX=TestData[,1:cols-1]
tempcol=data.frame()
for (i in 1:rows){
temp=classify(TestX[i,],ReferenceData,k=k)
tempcol=rbind(tempcol,temp)
}
TestData$tempY=tempcol[,ncol(tempcol)]
TestData$CutOrNot[TestData$tempY!=TestData[,cols]]='yes'
TestData$CutOrNot[TestData$tempY==TestData[,cols]]='no' #我原本直接使用TestY[i],发现最后结果都是一样的了，看了condition里面必须是跟列表有关的东西才可以
cutresult=TestData[which(TestData$CutOrNot=='no'),1:(ncol(TestData)-2)]
return (cutresult)
}
#测试
#随机生成参考数据集和测试数据集
a=randomsample(iris,20,50,50)
refer=a$data1
test=a$data2
verify=a$data3
#进行剪辑，获得剪辑后的数据cutresult
cuttestresult=cutsample(refer,test)
nrow(cutresult) #看看剩下多少数据
#使用剪辑后的数据作为knn分类的依据
result=MyKNN(verify[,1:ncol(verify)-1],cuttestresult)
#作图分析
plot(result$Sepal.Length,result$Sepal.Width,col=result$Species,
main='knn category',pch=18)
plot(verify$Sepal.Length,verify$Sepal.Width,col=verify$Species,
main='real result',pch=18)
#对比
total=merge(verify,result,by=c('Sepal.Length','Sepal.Width','Petal.Length','Petal.Width'))
colnames(total)[c(5,6)]=c('real','knn')
total$YesOrNot[total$real==total$knn]='yes'
total$YesOrNot[total$real!=total$knn]='no'
total</span><strong style="font-size: 18px;">
</strong>
测试结果也还不错，可能是因为iris本身就比较好区分的原因。改天拿其他数据试试
剪辑近邻法多用于数据量大的时候，毕竟有数据可以挥霍嘛，哈哈
11.30 偶尔一个小算法
惰性学习算法之KNN的R语言实现
#KNN自写版本
#传入要分类的单个向量，邻居的个数k，已知道所属类的数据集，最后返回其最大可能的类
classify<-function(vector,ClassifyData,k=5){
require(reshape2)
cols=ncol(ClassifyData)
data=ClassifyData[,1:cols-1]
alldistance=numeric(0)
for (i in 1:nrow(data)){
distance=sum((vector-data[i,])^2)
alldistance=c(alldistance,distance)
}
#以距离的倒数为权重
alldistance=data.frame(weight=1/alldistance,sequence=1:nrow(data),class=ClassifyData[,cols])
alldistance=alldistance[order(alldistance$weight),]
kNearest=tail(alldistance,k) #得到权重最高的几个值
m=melt(kNearest,id=c('class')) #用melt和cast计算各个类别的权重和
c=cast(m,class~variable,sum)
temp=c[order(c$weight,decreasing=TRUE),]
sortvector=cbind(vector,temp[1,1])
return (sortvector)
}
#对未分类的数据集进行分类，注意未分类的数据比已分类的数据少一列，那一列就是他们所属的类别
MyKNN<-function(UnClassifyData,ClassifyData,k=5){
rows_uns=nrow(UnClassifyData)
cols_s=ncol(ClassifyData)
result=as.data.frame(matrix(numeric(0),ncol=cols_s))
colnames(result)=colnames(ClassifyData)
for (i in 1:rows_uns){ #对数据集的每个数据进行分类
vect=classify(UnClassifyData[i,],ClassifyData,k=5)
result=rbind(result,vect)
}
colnames(result)=colnames(ClassifyData)
return (result)
}
#随机选取其中某些为已分好类别的，作为knn分类的依据数据
#将剩余的数据采用KNN进行分类
randomnum=sample(1:150,150,replace=FALSE)
picknum=randomnum[1:120]
unpicknum=randomnum[121:150]
picknum=picknum[order(picknum)]
unpicknum=unpicknum[order(unpicknum)]
ClassifyIris=iris[picknum,] #被选为已分好类的数据
UnClassifyIris=iris[unpicknum,c(1,2,3,4)] #被选为不知道类的数据
#作图分析
result=MyKNN(UnClassifyIris,ClassifyIris,k=5)
plot(result$Sepal.Length,result$Sepal.Width,col=result$Species,
main='knn category',pch=18)
unpick=iris[unpicknum,]
plot(unpick$Sepal.Length,unpick$Sepal.Width,col=unpick$Species,
main='real result',pch=18)
#对比
total=merge(unpick,result,by=c('Sepal.Length','Sepal.Width','Petal.Length','Petal.Width'))
colnames(total)[c(5,6)]=c('real','knn')
total$YesOrNot[total$real==total$knn]='yes' #分对的为yes
total$YesOrNot[total$real!=total$knn]='no' #分错的为no
total
使用iris数据集，对其中30个数据进行knn分类，效果良好，基本上只有1个到2个错误，真牛逼，total结果如下：
Sepal.Length Sepal.Width Petal.Length Petal.Width real knn YesOrNot
1 4.4 3.0 1.3 0.2 setosa setosa yes
2 4.4 3.2 1.3 0.2 setosa setosa yes
3 4.6 3.6 1.0 0.2 setosa setosa yes
4 4.8 3.0 1.4 0.3 setosa setosa yes
5 4.8 3.1 1.6 0.2 setosa setosa yes
6 4.9 3.1 1.5 0.2 setosa setosa yes
7 5.0 2.0 3.5 1.0 versicolor versicolor yes
8 5.0 3.5 1.3 0.3 setosa setosa yes
9 5.1 3.5 1.4 0.3 setosa setosa yes
10 5.1 3.8 1.5 0.3 setosa setosa yes
11 5.2 3.5 1.5 0.2 setosa setosa yes
12 5.4 3.4 1.5 0.4 setosa setosa yes
13 5.5 2.4 3.8 1.1 versicolor versicolor yes
14 5.6 2.9 3.6 1.3 versicolor versicolor yes
15 5.7 2.6 3.5 1.0 versicolor versicolor yes
16 5.7 2.9 4.2 1.3 versicolor versicolor yes
17 5.7 3.0 4.2 1.2 versicolor versicolor yes
18 5.8 2.6 4.0 1.2 versicolor versicolor yes
19 6.0 2.7 5.1 1.6 versicolor virginica no
20 6.0 2.9 4.5 1.5 versicolor versicolor yes
21 6.1 2.8 4.0 1.3 versicolor versicolor yes
22 6.2 3.4 5.4 2.3 virginica virginica yes
23 6.3 2.5 4.9 1.5 versicolor virginica no
24 6.4 2.8 5.6 2.1 virginica virginica yes
25 6.5 3.2 5.1 2.0 virginica virginica yes
26 6.6 3.0 4.4 1.4 versicolor versicolor yes
27 6.7 2.5 5.8 1.8 virginica virginica yes
28 6.8 3.0 5.5 2.1 virginica virginica yes
29 6.9 3.1 5.4 2.1 virginica virginica yes
30 7.3 2.9 6.3 1.8 virginica virginica yes
之后我又将已分类数据个数调整为50个，未分类的为100个，结果竟然只有2-6个左右是分错的，这准确性实在惊人！
11.29 偶尔一个小算法
聚类算法之k-means的R语言实现
Mymeans<-function(data,k,iter.max=10){
rows=nrow(data)
cols=ncol(data)
centers=matrix(0,nrow=k,ncol=cols) #储存中心的矩阵
rand=sample(1:rows,k,replace=FALSE)
centers=data[rand,] #随机初始化质心
rownames(centers)=c(1:k)
sortdata=as.data.frame(matrix(0,ncol=2,nrow=rows))
colnames(sortdata)=c('distance','category') #定义储存距离和所属类别的矩阵
iter=0 #记录迭代次数
pickdistance=0
pickcenter=0
while (iter<iter.max){
for(i in 1:rows){
for (j in 1:k){
distance=sum((data[i,]-centers[j,])^2)
if (pickdistance==0 | distance < pickdistance){
pickdistance=distance
pickcenter=j
}
}
pick=c(pickdistance,pickcenter)
sortdata[i,]=pick
pickdistance=0
pickcenter=0
} #以上的for计算每个点到质心的距离并选取离他最近的质心
for (j in 1:k){
classdata=data[which(sortdata$category==j),]
centers[j,]=colMeans(classdata)
} #更新质点
iter=iter+1
}
result=list(centers=centers,sortdata=sortdata)
return (result)
}
newiris=iris[,c(1,2,3,4)]
Mymeans(newiris,k=3,iter.max = 10)
kmeans(newiris,centers=3)PS :自己写的mymeans结果跟R自带的kmeans结果一样
PPS：后来又参考了网上别人写的代码，发现可以在当中加入一个变量changed，当每个点都没在更新其所属的cluster的时候，就直接跳出迭代，这样可以提高效率
11.28
跟导师去外面做了一周实验，没网真蛋疼。然后10号说的要做的数据分析小软件也没做出来T-T，rpy2的bug太多了，跟64位还不太撘，看来这个计划要搁置了，先实习最重要，之后偶尔抽下时间把这个软件做了，这次就直接用python的包来做吧。
然后这几天做实验回来也顺便思考了下，尤其是闲了下就又翻了下腾讯的国产漫画，平时也会看日本漫画，两者对比了下，就会很明显感觉到业余跟专业的区别，业余的画家，在分镜上的处理上，总是不够流畅，或者显的漏洞很多，这个缺点在画战斗分镜的时候尤其明显，简直惨不忍睹。。在回头一想，相对于本专业出身的人，转行的我也是一个业余选手吧。是的，就现在而言是个业余的。业余的要成为专业的，不是每天瞎干画很多很多话漫画，是要吸收画家的专业素养，在实际作画中融合进去，如此才能不断让自己像专业的靠拢，这么一想我就又仔细看了国产漫画，例如某一部的第一话和最新的第90几话，不得不说，画工确实变好了很多，虽然跟日本的专业级的仍然相去甚远，但是只要在不断成长，慢慢的，我们就会成为专业的。
11.10
这几天跟导师一起做项目，刚开始不太上心，总感觉影响自己学习，但是做着做着还是蛮有感触的，工科的东西，真的很严谨，电路板插线，只要稍微有个闪失，都是很大的毛病，各种毛病，不断检测排查，对严谨性的要求尤其之高。
这几天没怎么写代码，不过构思了下接下来要做的事，嘿嘿，已经想好要做什么了，决定要用Tkinter做一个可视化软件，就叫数据分析小帮手吧！把这2个月学的东西全部整合一下，因为学的是R分析，所以暂时就不学python了，所以软件的结构和功能大致是这样的：
1、Tkinter编写的可视化界面
2、界面上通过button实现rpy与R交互数据分析：
①导入excel或者csv格式的数据集，数据能显示在软件右侧
②对数据进行清理，去掉NA列、缺失数据列
③能够进行统计描述、相关性分析、t检验、散点图展示、线性回归分析
3、使用分类器算法对数据进行分类——if need
①二元线性感知器
②决策树分类
4、将数据存入数据库、并生成分析后的完整报告PDF
5、小游戏娱乐：内嵌爬虫程序。专门爬取招聘网上关于数据分析和挖掘的岗位来激励使用者
忒激动了，以上的功能几乎把我最近学的全部整合进去了，关键是他们之间还是相互联系的一个整体，简直exciting！！！
估计要到月底才能编完了 =_=，毕竟还要做项目，老师说了得最起码十天左右，断断续续之下应该能写好这个小程序，恩，加油！
写好程序就去找实习！希望能找到实习！
11.5
今天帮导师干杂事，搞得没心情学习，所以就打算编个贪吃蛇出来玩玩，然后就去搜了点pygame的教程，看了之后一发不可收拾，可是还是没整出贪吃蛇怎么编。。明晚抽时间继续搞起！
2015.11.4
辛辛苦苦在python里写的排序。。结果发现sort这个函数本身是具有判断数组大小并采用最合理的排序法的，他的速度简直令人震惊。。
ls=sample(range(100000),100000)
start1=time.clock()
a=ls.sort()
end1=time.clock()
print '%s' % (end1-start1)运行结果：
0.0587010113038s
OTZ。。。
另外，看别人写的代码真的能学到不少东西！今天累了所以找了个“文字游戏”的python代码，看着代码变百度，学到了不少句法，总结下：
round(x,n) #将浮点数x四舍五入小数点后n位
classmethod，staticmethod的用法 #可以引入cls或不传入self
temcolor #对输出赋予颜色和特效的库，常用有cprint和colored
__import__() #import语句实际调用来执行导入的函数
.join() #对夸号内的东西插入‘.’前面的字符
map(func,a) #对a施行fun，并最终返回数组
2015.11.2 一天一个小算法
快速排序：
#快速排序
def QuickSort(ls,l,r):
i=l
j=r
x=ls[i]
while i<j:
while i<j:
if ls[j]<x:
ls[i]=ls[j]
i+=1
break
else:
j-=1
while i<j:
if ls[i]>x:
ls[j]=ls[i]
j-=1
break
else:
i+=1
ls[i]=x
if l<r:
QuickSort(ls,l,i-1)
QuickSort(ls,i+1,r)
2015.10.31 一天一个小算法
归并排序：
#归并排序
#递归+合并
#合并两个有序组1
def MergeList(ls1,ls2):
temp=[]
while ls1 and ls2:
if ls1[0]<ls2[0]:
temp.append(ls1[0])
#ls1.pop(0)
del ls1[0]
else:
temp.append(ls2[0])
#ls2.pop(0)
del ls2[0]
while ls1:
temp.append(ls1[0])
#ls1.pop(0)
del ls1[0]
while ls2:
temp.append(ls2[0])
#ls2.pop(0)
del ls2[0]
return temp
#第二种合并两数组方法
def MergeList1(ls1,ls2):
temp=[]
n,m=len(ls1),len(ls2)
i,j=0,0
while i<n and j<m:
if ls1[i]<=ls2[j]:
temp.append(ls1[i])
i+=1
else:
temp.append(ls2[j])
j+=1
while i<n:
temp.append(ls1[i])
i+=1
while j<m:
temp.append(ls2[j])
j+=1
del ls1,ls2
return temp
#拆分成2个组
def SplitList(ls):
if len(ls)==1:
print 'unseperable'
return ls
mid=len(ls)/2
ls1=ls[0:mid]
ls2=ls[mid:len(ls)]
return (ls1,ls2)
#归并排序
def RecursiveAndMerge(ls):
if len(ls)>1:
ls1=RecursiveAndMerge(SplitList(ls)[0])
ls2=RecursiveAndMerge(SplitList(ls)[1])
return MergeList(ls1,ls2)
else:
return ls
#使用第二种合并数组法的归并排序
def RecursiveAndMerge1(ls):
if len(ls)>1:
ls1=RecursiveAndMerge(SplitList(ls)[0])
ls2=RecursiveAndMerge(SplitList(ls)[1])
return MergeList1(ls1,ls2)
else:
return ls
#分别计算下今天两种归并排序跟堆排序运算速度差距：
ls=sample(range(100000),100000) #sample表示随机生成一组无序的数列
start1=time.clock()
a=RecursiveAndMerge(ls)
end1=time.clock()
print '%ss' % (end1-start1)
ls=sample(range(100000),100000)
start2=time.clock()
b=SortHeap(ls)
end2=time.clock()
print '%ss' % (end2-start2)
ls=sample(range(100000),100000)
start3=time.clock()
c=RecursiveAndMerge1(ls)
end3=time.clock()
print '%ss' % (end3-start3)
###########################################################################################运算结果如下：
4.94025446845s #第一种归并：每次合成一个元素到新数组就删除一个元素
5.38941577259s #堆排序
2.91947808451s #第二种归并：合成两数组后才删除所有元素
由上结果可知，大数据情况下，归并排序确实比较优异，且损失空间的情况下，速度还可进一步提高，然后……python果然慢的跟乌龟一样=_=，这10万数字排序要是放在C++里，那可是毫秒级的………………
2015.10.31 一天一个小算法
堆排序：
#!usr/bin/env python
#-*- coding:utf-8 -*-
#堆排序
#要写的模块有插入堆后调整排序、删除堆后调整排序、建立最小堆、将堆完整排好序的方法
#节点i，则其父节点(i-1)/2,左右子节点2i+1/2i+2
#插入堆后排序
def InsertHeap(ls,num):
ls.append(num)
i=len(ls)-1
j=(i-1)/2
while j>=0 :
if ls[i]>ls[j]:
break
ls[i],ls[j]=ls[j],ls[i]
i=j
j=(i-1)/2
#删除堆第一个元素
def DeleteHeap(ls):
ls[0]=ls[len(ls)-1]
ls.pop()
i=0
j=2*i+1
while j<=len(ls)-1:
if j<len(ls)-1 and ls[2*i+1]>ls[2*i+2]:
j+=1
if ls[i]<ls[j]:
break
ls[i],ls[j]=ls[j],ls[i]
i=j
j=2*i+1
#生成最小堆,利用每次插入一个元素的办法
def GenerateHeap(ls1):
n=len(ls1)
ls=[]
for i in range(n):
InsertHeap(ls,ls1[0])
ls1.pop(0) #加入pop的原因是为了让空间复杂度始终为n
return ls
#堆重排列为有序数组
def SortHeap(ls):
n=len(ls)
ls=GenerateHeap(ls)
ls_sorted=[]
for i in range(n):
ls_sorted.append(ls[0])
DeleteHeap(ls)
return ls_sorted
ls=[11,2,3,33,22,23,5,4] #用数组ls验证，答案正确
print SortHeap(ls)
2015.10.30
突然想到昨天写的转二进制对负数不支持。。。那改成下面这样：
def mod(num,result=''):
if num <0:
num=abs(num)
print '-', #这个逗号可以让 print mod(-4)这个结果显示成- 100而不是换行显示
if num>=0 and num<2:
result=str(num)+result
return result
else:
result=str(num%2)+result
return mod(num/2,result)
2015.10.29
算法是个好东西………………
今天偷瞄了下<算法>第四版，学了一个二分查找，恩~
然后，本来打算睡了……突然想到算法书上一个二进制数溢出的问题，就想着自己编个小的递归来将数字转化成二进制输出的函数……又从床上爬起来码了下，哈哈，递归是个好东东，如下：
def mod(num,result=''):
if num<2:
result=str(num)+result
return result
else:
result=str(num%2)+result
return mod(num/2,result) #一开始写的是mod(num/2,result)
我在一开始最后一行写的是没加return的，结果执行的每次结果打印都是None，在代码节点中加了print来测试，发现执行的过程是没有问题的，但是最后整个打印却总是None，然后！纠结了一小会，自己拿笔重现了下过程，发现！如果最后一句不加return的话，那么递归之后的结果就是在最后一个mod会返回给上一个调用它的mod最后的值，但是之前的mod却得不到值了！也就是他们都是没有return值的！！也就是None，所以打印才会是None啊。。
会遇到这种问题的估计也就是我这种基础不好的小渣渣了吧。。哈哈
