CIYAWASAY

//畫箭頭
double x1 = fromPoint.getX();
double y1 = fromPoint.getY();
double x2 = toPoint.getX();
double y2 = toPoint.getY();
double distance = fromPoint.distance(toPoint);

double cita = Math.toDegrees(Math.asin(Math.abs(y1 - y2) / distance));
double subCitaSin = ARROW_LENGTH * Math.sin(Math.toRadians(cita - 30));
double subCitaCos = ARROW_LENGTH * Math.cos(Math.toRadians(cita - 30));
double addCitaSin = ARROW_LENGTH * Math.sin(Math.toRadians(cita + 30));
double addCitaCos = ARROW_LENGTH * Math.cos(Math.toRadians(cita + 30));
double up1, down1, up2, down2;
if(x1 > x2){
   //箭頭在第二象限
   if(y1 > y2){
      up1 = x2 + subCitaCos;
      down1 = y2 + subCitaSin;
      up2 = x2 + addCitaCos;
      down2 = y2 + addCitaSin;
   }
   //箭頭在第三象限
   else{
      up1 = x2 + subCitaCos;
      down1 = y2 - subCitaSin;
      up2 = x2 + addCitaCos;
      down2 = y2 - addCitaSin;
   }
}
else{
   //箭頭在第一象限
   if(y1 > y2){
      up1 = x2 - subCitaCos;
      down1 = y2 + subCitaSin;
      up2 = x2 - addCitaCos;
      down2 = y2 + addCitaSin;
   }
   //箭頭在第四象限
   else{
      up1 = x2 - subCitaCos;
      down1 = y2 - subCitaSin;
      up2 = x2 - addCitaCos;
      down2 = y2 - addCitaSin;
   }
}
g2d.draw(new Line2D.Double(new Point2D.Double(up1, down1), toPoint));
g2d.draw(new Line2D.Double(new Point2D.Double(up2, down2), toPoint));

import javax.swing.*;


import java.awt.*;

import java.awt.geom.*;

# posted by Unknown @ 23:56  0 comments

   Color color = Color.BLUE;
   String colorRGBText = "" + color.getRGB();

   Color color = new Color(Integer.parseInt(colorRGBText));

# posted by Unknown @ 12:58  0 comments

很久以前的一部卡通--美國鼠譚
這是裡面我最愛的一首歌--SOMEWHERE OUT THERE
小時後看的 劇情已經忘的差不多了 但這首歌一直記得
不知道大家有沒有看過~

《歌詞中英對照》

SOMEWHERE OUT THERE
外面那裡的某一個地方
（Barry Mann, Cynthia Weil, and James Horner）

Somewhere out there beneath the pale moonlight
外面那裡的某一個地方 在那蒼白的月光下
Someone\'s thinking of me and loving me tonight
今晚有個人正在想念著我 愛著我
Somewhere out there someone\'s saying a prayer
外面那裡的某一個地方 有個人正在祈禱
That we\'ll find one another in that dream somewhere out there
但願我們會找到彼此 在外面某一個地方的美夢裡

And even though I know how very far apart we are
而即使我知道我們相隔多麼遙遠
It helps to think we might be wishin\' on the same bright star
想到我們或許\正在對著同一顆星星許\願 就可以讓我好過許\多
And when the night wind starts to sing a lonesome lullaby
而當夜風開始唱一首寂寞的搖籃曲
It helps to think we\'re sleeping underneath the same big sky
想到我們睡在同一片寬闊的天空下 就可以讓我好過許\多

Somewhere out there if love can see us through
外面那裡的某一個地方 如果愛可以讓我們堅強
Then we\'ll be together somewhere out there
那麼我們將會團聚 在外面那裡的某一個地方
Out where dreams come true
某一個夢想可以成真的地方

# posted by Unknown @ 21:23  0 comments

比較各Sorts:
時間複雜度
in-place or not in-place
stable or unstable

《Sorts比較》

# posted by Unknown @ 08:53  0 comments

《Bubble Sort》

for i←1 to length[A]
   do for j←length[A] downto i+1
      do if A[j]<A[j-1]
         then exchange A[j]←→A[j-1]

void bubbleSort(int[] Array) {
   int temp;

   for (int i = 0; i < Array.length; i++) {
      for (int j = 0; j < (Array.length - i - 1); j++) {
         if (Array[j].score > Array[j + 1].score) {
            temp = Array[j].score;
            Array[j].score = Array[j + 1].score;
            Array[j + 1].score = temp;
         }
      }
   }
}

void bubbleSort(String[] Array) {
   String temp;

   for (int i = 0; i < Array.length; i++) {
      for (int j = 0; j < (Array.length - i - 1); j++) {
         if (Array[j].name.compareTo(Array[j + 1].name) > 0) {
            temp = Array[j].name;
            Array[j].name = Array[j + 1].name;
            Array[j + 1].name = temp;
         }
      }
   }
}

# posted by Unknown @ 08:41  0 comments

《Quick Sort》

if p<r

   then q←Partition(A,p,r)
      Quicksort(A,p,q-1)

   Quicksort(A,q+1,r)

x←A[r]
i←p-1
for j←p to r-1
   do if A[j]≦x

      then i←i+1
         exchange A[i]←→A[j]
exchange A[i+1]←→A[r]

return i+1

void quickSort(int[] Array, int p, int r){
   if(p < r){
      int q = partition(Array, p, r);
      quickSort(Array, p, q - 1);
      quickSort(Array, q + 1, r);
   }
}

int partition(int[] Array, int p, int r){
   int x = Array[r];
   int i = p - 1;

   for(int j = p; j <= r - 1; j++){
      if(Array[j] <= x){
         i++;
         int t1 = Array[i]; Array[i] = Array[j];
         Array[j] = t1;
      }
   }
   int t2 = Array[i+1]; Array[i+1] = Array[r]; Array[r] = t2;
   return i + 1;
}

int partition(String[] Array, int p, int r) {
   String x = Array[r].name;
   int i = p - 1;

   for (int j = p; j <= (r - 1); j++) {
      if (Array[j].name.compareTo(x) <= 0) {
         i++;

         String t1 = Array[i].name;
         Array[i].name = Array[j].name;
         Array[j].name = t1;
      }
   }

   String t2 = Array[i + 1].name;
   Array[i + 1].name = Array[r].name;
   Array[r].name = t2;

   return i + 1;
}

void quickSort(String[] Array) {
   quickSort(Array,0,Array.length-1);
}

void quickSort(String[] Array, int p, int r) {
   if (p < r) {
      int q = partition(Array, p, r);
      quickSort(Array, p, q - 1);
      quickSort(Array, q + 1, r);
   }
}

# posted by Unknown @ 08:28  0 comments

《Heap Sort》

return └i/2┘

return 2i

return 2i+1

l←Left(i)
r←Right(i)

if l≦heap-size[A] and A[l]>A[i]
   then largest←l

   else largest←i
if r≦heap-size[A] and A[r]>A[largest]
   then largest←r

if largest≠i
   then exchange A[i]←→A[largest]
      Max-Heapify(A,largest)

heap-size[A]←length[A]
for i←└length[A]/2┘ downto 1
   do Max-Heapify(A,i)

Build-Max-Heap(A)
for i ←length[A] downto 2
   do exchange A[1]←→A[i]
      heap-size[A]←heap-size[A]-1
   Max-Heapify(A,1)

int parent(int i){
   return (i - 1)/2;
}

int left(int i){
   return 2 * i + 1;
}

int right(int i){
   return 2 * i + 2;
}

void heapSort(int[] Array){
   buildMaxHeap( Array );
   for(int i = Array.length - 1; i >= 1; i--){
      int temp = Array[0]; Array[0] = Array[i]; Array[i] = temp;
      heapSize--;
      maxHeapify(Array, 0);
   }
}

void buildMaxHeap(int[] Array){
   heapSize = Array.length;
   for(int i = (int)( (Array.length/2) - 1 ); i >= 0; i--){
      maxHeapify(Array, i);
   }
}

void maxHeapify(int[] Array, int i){
   int L = left(i);
   int R = right(i);
   int largest;
   if( (L < heapSize) && (Array[L] > Array[i]) )
      largest = L;
   else
      largest = i;
   if( (R < heapSize) && (Array[R] > Array[largest]) )
      largest = R;
   if(largest != i){
      int temp = Array[i]; Array[i] = Array[largest];
      Array[largest] = temp;
      maxHeapify(Array, largest);
   }
}

int parent(int i){
   return (i - 1)/2;
}

int left(int i){
   return 2 * i + 1;
}

int right(int i){
   return 2 * i + 2;
}

void buildMaxHeap(String[] Array) {
   heapSize = Array.length;

   for (int i = (int) ((Array.length / 2) - 1); i >= 0; i--) {
      maxHeapify(Array, i);
   }
}

void maxHeapify(String[] Array, int i) {
   int L = left(i);
   int R = right(i);
   int largest;

   if ((L < heapSize) && (Array[L].name.compareTo(Array[i].name) > 0)) {
      largest = L;
   } else {
      largest = i;
   }

   if ((R < heapSize) && (Array[R].name.compareTo(Array[largest].name) > 0)) {
      largest = R;
   }

   if (largest != i) {
      String temp = Array[i].name;
      Array[i].name = Array[largest].name;
      Array[largest].name = temp;
      maxHeapify(Array, largest);
   }
}


void heapSort(String[] Array) {
   buildMaxHeap(Array);

   for (int i = Array.length - 1; i >= 1; i--) {
      String temp = Array[0].name;
      Array[0].name = Array[i].name;
      Array[i].name = temp;
      heapSize--;
      maxHeapify(Array, 0);
   }
}

# posted by Unknown @ 00:23  0 comments

《Merge Sort》

n1←q-p+1

n2←r-q
△cerate arrays L(1..n1+1) and R(1..n2+1)

for i←1 to n1
   do L[i]←A[p+i-1]

for j←1 to n2
   do R[j]←A[q+j]

L[n1+1]←∞
R[n2+1]←∞
i←1
j←1
for k←p to r

   do if L[i]≦R[j]
      then A[k]←L[i]
         i←i+1
      else A[k]←R[j]
         j←j+1

if p<r

   then q←└(p+r)/2┘
   Merge-Sort(A,p,q)
   Merge-Sort(A,q+1,r)
   Merge(A,p,q,r)

void mergeSort(int[] Array, int p, int r){
   if( p < r ){
      int q = ( p + r )/2;
      mergeSort(Array, p, q);
      mergeSort(Array, q + 1, r);
      merge(Array, p, q, r);
   }
}

void merge(int[] Array, int p, int q, int r){
   int n1 = q - p + 1;
   int n2 = r - q;
   int[] L = new int[n1 + 1], R = new int[n2 + 1];
   int i, j;
   for(i = 0; i < n1; i++){
      L[i] = Array[p + i];
   }
   for(j = 0; j < n2; j++){
      R[j] = Array[q + j + 1];
   }
   L[n1] = R[n2] = Integer.MAX_VALUE;
   i = j = 0;
   for(int k = p; k <= r; k++){
      if(L[i] <= R[j]){
         Array[k] = L[i];
         i++;
      }
      else{
         Array[k] = R[j];
         j++;
      }
   }
}

void mergeSort(String[] Array){
   mergeSort(Array,0,Array.length-1);
}

void mergeSort(String[] Array, int p, int r) {
   if (p < r) {
      int q = (p + r) / 2;
      mergeSort(Array, p, q);
      mergeSort(Array, q + 1, r);
      merge(Array, p, q, r);
   }
}
   
void merge(String[] Array, int p, int q, int r) {
   int n1 = q - p + 1;
   int n2 = r - q;
   String[] L = new String[n1 + 1];
   String[] R = new String[n2 + 1];
   int i;
   int j;

   for (i = 0; i < n1; i++) {
      L[i] = Array[p + i].name;
   }

   for (j = 0; j < n2; j++) {
      R[j] = Array[q + j + 1].name;
   }

   L[n1] = R[n2] = new String(new char[]{Character.MAX_VALUE});
   i = j = 0;

   for (int k = p; k <= r; k++) {
      if (L[i].compareTo(R[j])<= 0) {
         Array[k].name = L[i];
         i++;
      } else {
         Array[k].name = R[j];
         j++;
      }
   }
}

# posted by Unknown @ 00:01  0 comments

《Insertion Sort》

for j←2 for length[A]
   do key←A[j]
      △Insert A[j] into the sorted sequence A[1..j-1]

      i←j-1
      while i>0 and A[i]>key
         do A[i+1]←A[i]
            i←i-1
         A[i+1]←key

void insertionSort(int[] Array){
   for(int j = 1; j < Array.length; j++){
      int key = Array[j];
      int i = j - 1;
      while( (i >= 0) && (Array[i] > key) ){
         Array[i+1] = Array[i];
         i--;
      }
      Array[i+1] = key;
   }
}

void insertionSort(String[] Array) {
   for (int j = 1; j < Array.length; j++) {
      String key = Array[j].name;
      int i = j - 1;

      while ((i >= 0) && (Array[i].name.compareTo(key)> 0)) {
         Array[i + 1].name = Array[i].name;
         i--;
      }

      Array[i + 1].name = key;
   }
}

# posted by Unknown @ 23:30  0 comments

网络交流方式介绍- Wikibooks

wiki可以定義為網上協作寫作系統，屬於“可寫web”的一種。wiki好比軟體發展中的cvs一樣，也屬於協作開發系統。在wiki中，每一頁都是可以編輯的。wiki比起論壇和新聞系統來，能提供效果更好的知識庫。
wikiwiki是夏威夷語“快速”的意思。在這裏指能快速編輯網頁並快速建立新網頁、快速建立鏈結。
在一般的網站上，網頁都是唯讀的，而wiki網頁不但能閱讀，而且能直接修改。能發揮網路互動的優勢，使wiki頁面總是鮮活的。wiki 網站不象一般網站那樣區分讀者和編者，每個讀者都可以作為編者，都可以是網站的主人，一個wiki網站上的內容常常是多個人共同的心血，每個人可以隨時加 入網站的建設。wiki能聚集很多人的智慧，而不是只展示幾個人的智慧。
wiki和論壇相比，論壇只能發消息，wiki不但能發消息，而且能把消息用超鏈結有效的組織起來。wiki還能使多個人共同編輯同一篇文章，使一個文章能像軟體一樣隨時間不斷完善。

• 最基本的是結構化文本功能
• 用戶註冊功能
• 版本歷史功能
• 版本間的比較功能
• 最新更改功能
• 多wiki功能，就是運行一個wiki系統，能夠在“鏈結字”、“最近更動”方面區分為不相干的多個系統。不要本來無關的主題，在同一個最近更動裏出現。最好管理和授權工作也是能分開的。如果能選擇搜索層次更好
• 有完善的wiki管理功能。強大的授權管理功能。最好是web方式的管理。如果從管理上來說zope上的zwiki是比較理想的
• 鎖頁功能
• 頁面監視功能。頁面改變後能email通知監視人

# posted by Unknown @ 12:13  0 comments