一、今日收穫

1.比較值

1.1 最大值

兩個數：if(a>b) max=a;

多個數：

• 遍歷時，每個數值與最大值比較

 1 public class study {
 2 public static void main(String[] args) {
 3     int[] a= {2,3,4,5,9,7,8};
 4     int max=0;
 5     for(int i=0;i<a.length;i++) {
 6         if(a[i]>max) {
 7             max=a[i];
 8         }
 9     }
10     System.out.println("最大值是："+max);
11     }
12 }

• 遍歷時，兩兩相鄰比較找最大值

 1 public class study {
 2 public static void main(String[] args) {
 3     int[] a= {2,3,4,5,9,7,8};
 4     int max=0;
 5     for(int i=0;i<a.length-1;i++) {
 6         if(a[i]>a[i+1]&&a[i]>max) {
 7             max=a[i];
 8         }else if(a[i+1]>a[i]&&a[i+1]>max) {
 9             max=a[i+1];
10         }
11     }
12     System.out.println("最大值是："+max);
13     }
14 }

• 將陣列分為兩部分，將後部分逐一與前部分每個值比較

 1 public class study {
 2 public static void main(String[] args) {
 3     int[] a= {2,3,4,5,9,7,8};
 4     int max=0;
 5     for(int i=0;i<a.length;i++) {
 6         for(int j=i-1;j>=0;j--) {
 7             /**
 8              * 將陣列分為兩部分
 9              * 將後部分的第一個逐一與前部分每一個比較
10              * 如果當前元素大，並且也大於最大值變數，則將當前元素賦值給最大值變數
11              */
12             if(a[j+1]>a[j]&&a[j+1]>max) {
13                 max=a[j+1];
14                 }
15             }
16         }
17     System.out.println("最大值是："+max);
18     }
19 }

1.2 最小值

兩個數：if(a<b) min=a;

多個數：

• 遍歷時，每個數值與最小值比較

• 遍歷時，兩兩相鄰比較找最小值

• 將陣列分為兩部分，將後部分逐一與前部分每個值比較

1.3 平均值

一組資料的和除以資料的個數

2.數字排序

2.1 氣泡排序

原理：

• 逐一比較陣列中相鄰的兩個元素，如果後面的數字小於前面的數字，就交換先後元素

• 經過一個輪次的比較，一定有一個最大的排在最後的位置

• 每次比較剩下的元素，經過n-1次比較，可以實現排序

程式碼：

 1 import java.util.Arrays;
 2 public class study {
 3 public static void main(String[] args) {
 4     int[] a= {2,3,4,5,9,7,8};
 5     for(int i=0;i<a.length-1;i++) {
 6         for(int j=0;j<a.length-i-1;j++) {
 7             if(a[j]>a[j+1]) {
 8                 int t=a[j];
 9                 a[j]=a[j+1];
10                 a[j+1]=t;
11             }
12         }
13     }
14     System.out.println("排序後的陣列："+Arrays.toString(a));
15     }
16 }

2.2 選擇排序

原理：

• 將陣列中的每個元素與第一個元素比較，如果這個元素小於第一個元素，就將這兩個元素交換位置

• 每輪使用第一步的規則可以選擇出一個最小元素放到第一個位置

• 經過n–1輪比較完成排序

程式碼：

 1 import java.util.Arrays;
 2 public class study {
 3 public static void main(String[] args) {
 4     int[] a= {2,3,4,5,9,7,8};
 5     for(int i=0;i<a.length-1;i++) {
 6         for(int j=i+1;j<a.length;j++) {
 7             if(a[i]>a[j]) {
 8                 int t=a[i];
 9                 a[i]=a[j];
10                 a[j]=t;
11             }
12         }
13     }
14     System.out.println("排序後的陣列："+Arrays.toString(a));
15     }
16 }

2.3 插入排序

原理：

• 將陣列分為兩部分，將後部分的每一個元素逐一與前部分每一個元素比較，如果當前元素小，就替換

• 找到合理位置插入

程式碼：

 1 import java.util.Arrays;
 2 public class study {
 3 public static void main(String[] args) {
 4     int[] a= {2,3,4,5,9,7,8};
 5     int i,j,k;
 6     for(i=1;i<a.length;i++) {
 7         k=a[i];
 8         for(j=i-1;j>=0&&k<a[j];j--) {
 9             a[j+1]=a[j];
10             }
11         a[j+1]=k;
12         }
13     System.out.println("排序後的陣列："+Arrays.toString(a));
14     }
15 }

2.4 快速排序

原理：

• 首先選定基準值，一般設定low所對應的元素位置為基準值

• 在高位指標始終不小於低位指標的前提下，

高位指標開始判斷其是否比基準值大，如果符合高位指標減1，繼續尋找，直到找到不符合的情況，然後把該值賦給此時低位所在位置。
低位指標開始判斷是否比基準值小，如果符合，低位指標加1，繼續尋找，直到找到不符合情況，然後把該值賦給此時高位指標所指位置。
如此反覆，直到低位高位指標重合，此時再將當前的基準值賦給低位指標所指的值，這樣就完成了一次排序。此時，基準值就到了其最終位置上，然後繼續對以基準值為界的兩部分進行排序。

程式碼：

 1 import java.util.Arrays;
 2 public class QuickSortDemo{
 3 public static void main(String[] args) {
 4     int vec[]= {37,47,23,100,19,56,56,99,9};
 5     QuickSortDemo q=new QuickSortDemo();
 6     q.quicksort(vec,0,vec.length-1);
 7     System.out.println("排序後："+Arrays.toString(vec));
 8 }
 9 public void quicksort(int a[],int low,int high) {
10     if(low<high) {
11         int pivot,p_pos,i;
12         p_pos=low; //p_pos指向low,即位索引為0位置
13         pivot=a[p_pos]; //將0位置上的數值賦給pivot
14         for(i=low+1;i<=high;i++) {
15             if(a[i]>pivot) {
16                 p_pos++;
17                 int tmp=a[p_pos];
18                 a[p_pos]=a[i];
19                 a[i]=tmp;
20             }
21         }
22         int tmp=a[low];
23         a[low]=a[p_pos];
24         a[p_pos]=tmp;
25         quicksort(a,low,p_pos-1); //遞迴呼叫，排序左半區
26         quicksort(a,p_pos+1,high); //遞迴呼叫，排序右半區
27     }
28     }
29 }

3.查詢

3.1 順序查詢

基本思想：讓關鍵字與佇列中的數從第一個開始逐個比較，直到找到與給定關鍵字相同的數為止。若全部比較也沒有找到與關鍵字相同的數，即查詢失敗。

 1 public class study{
 2 public static void main(String[] args) {
 3     //定義一維資料
 4     int[] ary= {2,3,4,5,9,7,8};
 5     //定義要查詢的資料
 6     int find=5;
 7     //定義標示符，即找到的位置
 8     int count=-1;
 9     for(int i=0;i<ary.length;i++) {
10         if(find==ary[i]) {
11             count=i;
12         }
13     }
14     if(count!=-1) {
15         System.out.println("下標在："+count+"的位置");
16     }else {
17         System.out.println("對不起，沒有找到！");
18     }
19     }
20 }

3.2 二分查詢

步驟：

• 查詢前，元素須進行排序

• 確定區域中的中間位置：mid=(low+high)/2

• 行待查的k值與V[mid...n]key比較：若相等，則查詢成功並返回此位置，否則需確定新的查詢區域，繼續二分查詢

 1 public class study{
 2 public static void main(String[] args) {
 3     //定義一維資料
 4     int[] a= {2,3,4,5,9,7,8};
 5     //定義要查詢的資料
 6     int find=5;
 7     //定義標示符，即找到的位置
 8     int count=-1;
 9     int low=0;
10     int high=a.length-1;
11     while(low<=high) {
12         int mid=(low+high)/2;
13         if(a[mid]==find) {
14             count=mid;
15             break;
16         }
17         else if(a[mid]>find) {
18             high=mid-1;
19         }
20         else {
21             low=mid+1;
22         }
23     }
24     if(count!=-1) {
25         System.out.println("下標在："+count+"的位置");
26     }else {
27         System.out.println("對不起，沒有找到！");
28     }
29     }
30 }