[持續更新]總結與感悟:代碼與狼生

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啊。。

會遇到這種問題的估計也就是我這種基礎不好的小渣渣了吧。。哈哈