知識點總結之-基礎語法練習

第7天 Java基礎語法
今日內容介紹
 循環練習
 數組方法練習
第1章 循環練習
1.1 編寫程序求 1+3+5+7+……+99 的和值。
題目分析：
通過觀察發現，本題目要實現的奇數（範圍1-100之間）的累加和。

1. 爲了記錄累加和的值，我們需要定義一個存儲累加和的變量
2. 我們要獲取到1-100範圍內的數
3. 判斷當前數是否爲奇數，是奇數，完成累加和操作
4. 累加完畢後，最終顯示下累加和的值
   解題步驟：
5. 定義一個用來記錄累加和的變量
6. 使用for循環語句，完成1-100之間每個數的獲取
7. 使用if條件語句，判斷當前數是否是奇數，是奇數，進行累加和操作
8. 使用輸出語句，打印累加和變量的值

代碼如下：
public class Test01 {
public static void main(String[] args) {
int sum = 0;
for (int i = 0; i < 100; i++) {
if (i%2==1) {
sum += i;
}
}
System.out.println("累加和的值 " + sum);
}
}

1.2 輸出所有的水仙花數，所謂水仙花數是指一個數3位數，其每位數字立方和等於其本身，如153 = 111 + 333 + 555
題目分析：
通過觀察發現，本題目要實現打印符合要求的數字（即水仙花數）。

1. 明確什麼樣的數就是水仙花數。水仙花數是指一個3位數（100-999之間），其每位數字立方之和等於該3位數本身。如153 = 111 + 333 + 555，
   即 3位數本身 = 百位數立方 + 十位數立方 + 個位數立方;

2. 獲取水仙花範圍內的所有3位數（100-999之間的每個3位數）

3. 判斷該3位數是否滿足水仙花數，滿足，打印該3位數
   解題步驟：

4. 使用for循環，得到100-999之間的每個3位數

5. 獲取3位數中百位數字、十位數字、個位數字

6. 使用if條件語句，判斷該3位數是否滿足水仙花數，滿足，使用輸出語句，打印該3位數
   代碼如下：
   public class Test02 {
   public static void main(String[] args) {
   for (int i = 100; i < 1000; i++) {
   int bai = i/100%10;
   int shi = i/10%10;
   int ge = i%10;

   	if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge) {
   		System.out.println(i);
   	}
   }
   

   }
   }

1.3 ASCII編碼表
American Standard Code for Information Interchange，美國標準信息交換代碼.
在計算機中，所有的數據在存儲和運算時都要使用二進制數表示, a、b、c、d這樣的52個字母（包括大寫）、以及0、1等數字還有一些常用的符號, 在計算機中存儲時也要使用二進制數來表示，而具體用哪些二進制數字表示哪個符號，當然每個人都可以約定自己的一套（這就叫編碼），而大家如果要想互相通信而不造成混亂，那麼大家就必須使用相同的編碼規則，於是美國有關的標準化組織就出臺了ASCII編碼，統一規定了上述常用符號用哪些二進制數來表示。

數字0-9對應ASCII編碼十進制爲48-57, 字母a-z對應ASCII編碼十進制爲97-122，字母A-Z對應ASCII編碼十進制爲65-90
1.4 利用for循環打印ABCDEFG…XYZ，26個大寫字母與26個小寫字母
題目分析：
通過觀察發現，本題目要實現打印26個大寫字母、26個小寫字母

1. 一共26個大小寫字母，那麼，可以考慮循環26次。在每次循環中，完成指定字母的大小寫打印
2. 找出ABCDEFG…XYZ這些字母之間的變化規律
   通過ASCII表發現，後面的字母比它前面的字母，ASCII值大1
   下一個字母 = 上一個字母 + 1
   如： A B C D
   65 66 67 68
   3. 在每次循環中打印上一個字母大小寫，並指定下一個字母
      解題步驟：
3. 定義初始化大寫變量，值爲’A’； 初始化小寫變量，值爲’a’
4. 使用for循環，進行26次循環
5. 在每次循環中，打印大寫字母、小寫字母。
   每次打印完成後，更新大寫字母值、小寫字母值
   代碼如下：
   public class Test04 {
   public static void main(String[] args) {
   char da = ‘A’;
   char xiao = ‘a’;
   for (int i = 0; i < 26; i++) {
   System.out.println("大寫字母 “+da+” ,小寫字母 "+xiao);
   da++; //更新大寫字母值
   xiao++; //更新小寫字母值
   }
   }
   }
   1.5 利用for循環打印 99 表?
   如：
   11=1
   12=2 22=4
   13=3 23=6 3*3=9

題目分析：
通過觀察發現，如果把11=1這樣的內容 看做一顆的話，那麼打印結果就成了如下效果：
*
**
***
…
這樣，就是打印9行星，每行打印星的個數與當前行數相等。
再觀察“13=3 23=6 33=9”得出它們如下的變化規律：
每行第n次 +""+ 行號 +"="+ 每行第n次 * 行號
如: 1 +""+ 2 +"="+ 12; // 相當於12=2
2 +""+ 2 +"="+ 22; // 相當於22=4

解題步驟：

1. 定義一個外層for循環，初始值從1開始，循環9次。用來控制打印的行數
2. 在外層for循環內部，定義一個for循環，初始值從1開始，循環次數與當前行數相等。用來完成每行打印指定次數的乘法公式 如1*1=1
3. 在內層for循環中，完成每行指定次數的乘法公式打印 如11=1
   System.out.print(k +""+ j +"="+ j*k +"\t");
   // 變量k代表：每行中的第n次
   // 變量j代表：行號
4. 在外循環中，當每行指定次數的乘法公式打印完畢後，通過System.out.println()切換到下一行。這樣，再次打印乘法公式時，就在下一行輸出打印了
   代碼如下：
   public class Test05 {
   public static void main(String[] args) {
   for (int j = 1; j < 10; j++) {
   for (int k = 1; k <= j; k++) {
   System.out.print(k +""+ j +"="+ jk +"\t");
   }
   System.out.println();
   }
   }
   }

第2章 數組方法練習
2.1 定義打印數組元素方法,按照給定的格式打印[11, 33, 44, 22, 55]
題目分析：
通過觀察發現，本題目要實現按照指定格式，打印數組元素操作

1. 通過循環，我們可以完成數組中元素的獲取，數組名[索引]
2. 觀察發現，每個數組元素之間加入了一個逗號”,”進行分隔；並且，整個數組的前後有一對中括號”[]”包裹數組所有元素。
   解題步驟：
3. 使用輸出語句完成打印 左邊的中括號”[”
4. 使用循環，輸出數組元素值。輸出元素值分爲兩種情況，如下：
   a) 最後一個數組元素，加上一個右邊的中括號”]”
   b) 非最後一個數組元素，加上一個逗號”,”
   代碼如下：
   //打印數組
   public static void printArray(int[] arr) {
   System.out.print("[");
   for (int i = 0; i < arr.length; i++) {
   if (i == arr.length - 1) {
   System.out.println(arr[i]+"]");
   } else {
   System.out.print(arr[i]+", ");
   }
   }
   }
   2.2 數組元素逆序
   圖解：

題目分析：
通過觀察發現，本題目要實現原數組元素倒序存放操作。即原數組存儲元素爲{11,22,33,44}，逆序後爲原數組存儲元素變爲{44,33,22,11}。

1. 通過圖解發現，想完成數組元素逆序，其實就是把數組中索引爲start與end的元素進行互換。
2. 每次互換後，start索引位置後移，end索引位置前移，再進行互換
3. 直到start位置超越了end位置，互換結束，此時，數組元素逆序完成。
   解題步驟：
4. 定義兩個索引變量start值爲0，變量end值爲數組長度減去1（即數組最後一個元素索引）
5. 使用循環，完成數組索引start位置元素與end位置元素值互換。
6. 在循環換過程中，每次互換結束後，start位置後移1，end位置前移1
7. 在循環換過程中，最先判斷start位置是否超越了end位置，若已超越，則跳出循環
   代碼如下：
   //數組元素逆序
   public static void receive(int[] arr){
   for (int start = 0, end = arr.length-1; start < end; start++,end–) {
   int temp = arr[start];
   arr[start] = arr[end];
   arr[end] = temp;
   }
   }

2.3 數組元素選擇排序
圖解：

題目分析：
通過觀察發現，本題目要實現把數組元素{13,46,22,65,3}進行排序

1. 提到數組排序，就要進行元素值大小的比較，通過上圖發現，我們想完成排序要經過若干次的比較才能夠完成。
2. 上圖中用每圈要比較的第一個元素與該元素後面的數組元素依次比較到數組的最後一個元素，把小的值放在第一個數組元素中，數組循環一圈後，則把最小元素值互換到了第一個元素中。
3. 數組再循環一圈後，把第二小的元素值互換到了第二個元素中。按照這種方式，數組循環多圈以後，就完成了數組元素的排序。這種排序方式我們稱爲選擇排序。
   解題步驟：
4. 使用for循環（外層循環），指定數組要循環的圈數（通過圖解可知，數組循環的圈數爲數組長度 - 1）
5. 在每一圈中，通過for循環（內層循環）完成數組要比較的第一個元素與該元素後面的數組元素依次比較到數組的最後一個元素，把小的值放在第一個數組元素中
6. 在每一圈中，要參與比較的第一個元素由第幾圈循環來決定。如上圖所示
   a) 進行第一圈元素比較時，要比較的第一個元素爲數組第一個元素，即索引爲0的元素
   b) 進行第二圈元素比較時，要比較的第一個元素爲數組第二個元素，即索引爲1的元素
   c) 依次類推，得出結論：進行第n圈元素比較時，要比較的第一個元素爲數組第n個元素，即數組索引爲n-1的元素
   代碼如下：
   //選擇排序
   public static void selectSort(int[] arr) {
   //功能
   //外層循環用來控制數組循環的圈數
   for (int i = 0; i < arr.length-1; i++) {
   //內層循環用來完成元素值比較，把小的元素值互換到要比較的第一個元素中
   for (int j = i+1; j < arr.length; j++) {
   if (arr[i] > arr[j]) {
   int temp = arr[i];
   arr[i] = arr[j];
   arr[j] = temp;
   }
   }
   }
   }
   2.4 數組元素冒泡排序
   圖解：數組元素{13,46,22,65,3}

題目分析：
通過觀察發現，本題目要實現把數組元素{13,46,22,65,3}進行排序

1. 提到數組排序，就要進行元素值大小的比較，通過上圖發現，我們想完成排序要經過若干次的比較才能夠完成。
2. 上圖中相鄰的元素值依次比較，把大的值放後面的元素中，數組循環一圈後，則把最大元素值互換到了最後一個元素中。數組再循環一圈後，把第二大的元素值互換到了倒數第二個元素中。按照這種方式，數組循環多圈以後，就完成了數組元素的排序。這種排序方式我們稱爲冒泡排序。
   解題步驟：
3. 使用for循環（外層循環），指定數組要循環的圈數（通過圖解可知，數組循環的圈數爲數組長度 - 1）
4. 在每一圈中，通過for循環（內層循環）完成相鄰的元素值依次比較，把大的值放後面的元素中
5. 每圈內層循環的次數，由第幾圈循環來決定。如上圖所示
   a) 進行第一圈元素比較時，內層循環次數爲數組長度 - 1
   b) 進行第二圈元素比較時，內層循環次數爲數組長度 - 2
   c) 依次類推，得出結論：進行第n圈元素比較時，內層循環次數爲數組長度 - n
   代碼如下：
   //冒泡排序
   public static void bubbleSort(int[] arr) {
   //功能
   //外層循環用來控制數組循環的圈數
   for (int i = 0; i < arr.length-1; i++) {
   //j < arr.length-1 爲了避免角標越界
   //j < arr.length-1-i 爲了比較效率,避免重複比較
   //內層循環用來完成元素值比較，把大的元素值互換到後面
   for (int j = 0; j < arr.length-1-i; j++) {
   if (arr[j] > arr[j+1]) {
   int temp = arr[j];
   arr[j] = arr[j+1];
   arr[j+1] = temp;
   }
   }
   }
   }

2.5 數組元素普通查找
圖解：

題目分析：
通過觀察發現，本題目要實現查找指定數值第一次在數組中存儲的位置（索引），返回該位置（索引）。

1. 我們可以通過遍歷數組，得到每個數組元素的值
2. 在遍歷數組過程中，使用當前數組元素值與要查找的數值進行對比
   a) 數值相等，返回當前數組元素值的索引
   b) 整個循環結束後，比對結果數值沒有相等的情況，說明該數組中沒有存儲要查找的數值，此時，返回一個索引值-1，來表示沒有查詢到對應的位置。（使用 -1來表示沒有查詢到，是因爲數組的索引沒有負數）
   解題步驟：
3. 使用for循環，遍歷數組，得到每個數組元素值
4. 在每次循環中，使用if條件語句進行當前數組元素值與要查找的數值進行對比，若比較結果相等，直接返回當前數組元素的索引值
5. 若整個循環結束後，比對結果數值沒有相等的情況，說明該數組中沒有存儲要查找的數值，此時，返回一個索引值-1
   代碼如下：
   //普通查找
   public static int getArrayIndex(int[] arr, int number) {
   //把數組中的元素依次與指定的數值 進行比較
   for (int i = 0; i < arr.length; i++) {
   if (arr[i] == number) {
   //找到了
   return i;
   }
   }
   return -1;
   }

2.6 數組元素二分查找（折半查找）
圖解：

題目分析：
通過觀察發現，本題目要實現查找指定數值在元素有序的數組中存儲的位置（索引），返回該位置（索引）。

1. 我們使用數組最中間位置的元素值與要查找的指定數值進行比較，若相等，返回中間元素值的索引
2. 最中間位置的元素值與要查找的指定數值進行比較，若不相等，則根據比較的結果，縮小查詢範圍爲上次數組查詢範圍的一半；
   再根據新的查詢範圍，更新最中間元素位置，然後使用中間元素值與要查找的指定數值進行比較
    比較結果相等，返回中間元素值的索引
    比較結果不相等，繼續縮小查詢範圍爲上次數組查詢範圍的一半，更新最中間元素位置，繼續比較，依次類推。
3. 當查詢範圍縮小到小於0個元素時，則指定數值沒有查詢到，返回索引值-1。
   解題步驟：
4. 定義3個用來記錄索引值的變量，變量min記錄當前範圍最小索引值，初始值爲0；變量max記錄當前範圍最大索引值，初始值爲數組長度-1；變量mid記錄當前當前範圍最中間元素的索引值，初始值爲(min+max) / 2
5. 使用循環，判斷當前範圍下，最中間元素值與指定查找的數值是否相等
    若相等，結束循環，返回當前範圍最中間元素的索引值mid
    若不相等，根據比較結果，縮小查詢範圍爲上一次查詢範圍的一般
    中間元素值 比 要查詢的數值大，說明要查詢的數值在當前範圍的最小索引位置與中間索引位置之間，此時，更新查詢範圍爲:
   範圍最大索引值 = 上一次中間索引位置 -1；
    中間元素值 比 要查詢的數值小，說明要查詢的數值在當前範圍的最大索引位置與中間索引位置之間，此時，更新查詢範圍爲:
   範圍最小索引值 = 上一次中間索引位置 +1；
    在新的查詢範圍中，更新中間元素值的位置，再次使用最中間元素值與指定查找的數值是否相等。
   中間索引值 = (範圍最小索引值 +範圍最大索引值) / 2;
6. 每次查詢範圍縮小一半後，使用if語句判斷，查詢範圍是否小於0個元素，若小於0個元素，則說明指定數值沒有查詢到，返回索引值-1。

代碼如下：
//二分查找法(折半查找法)
public static int halfSearch(int[] arr, int number) {
//定義3個變量，用來記錄min, min, mid的位置
int min = 0;
int max = arr.length-1;
int mid = 0;
while (min <= max) {
mid = (min+max)/2;
//沒找了， 更新範圍，繼續比較
//更新範圍
if (arr[mid] > number) {
//在左邊
max = mid-1;
} else if(arr[i] < number){
//在右邊
min = mid+1;
}
else{
return mid ;
}

return -1;

}