---
# System prepended metadata

title: 目前學到的函式寫法彙整

---

#  目前學到的函式寫法彙整



   
  
## 8/17~8/21(第一周)目前學到的函式



* 輸入指定範圍內的數，(有提示字串，最小值，最大值，有設中斷點int[] arr)

解釋中斷點 如果設定要輸入0~100，那如果main中斷點設-1 
那此方法不可能輸入的到-1，因為會一直超出範圍
則在使用函式時候，最後一個輸入值 放入new int[]{-1}
例如
```java=
int n =getNum("請輸入範圍:",0,100,new int[]{-1});
```
這樣當函式內判定你輸入-1時候，因為跟中斷點內設的值相同則直接return
-1 就會被回傳出來，達到回傳到範圍外的數字的要求

平常不需要回傳範圍內以外的數字時，就將中斷點那格填為null，例如
```java=
int n =getNum("請輸入範圍:",0,100,null);
```

* 回傳指定範圍的數字方法

```java=
  public static int getNum(String hint, int min, int max, int[] avs) {
        Scanner sc = new Scanner(System.in);
        int n;
        do {
            System.out.print(hint + "(" + min + "~" + max + "):");
            n = sc.nextInt();
            if (avs != null) {
                for (int i = 0; i < avs.length; i++) {
                    if (n == avs[i]) {
                        return n;
                    }
                }
            }
            if (n >= min && n <= max) {
                return n;
            }
            System.out.println("數字不符合規範,請重新輸入");
        } while (true);
    }
```




* 逐步搜尋法


```java=
  public static int linearSearch(int key, int[] arr, int count) {
        for (int i = 0; i < count; i++) {
            if (arr[i] == key) {
                return i;
            }
        }
        return -1;
    }
```

* 二元搜尋法
```java=
public static int binarySearch(int key, int[] arr, int count) {
        int left = 0;
        int right = count - 1;
        while (left <= right) {
            int middle = (left + right) / 2;
            if (arr[middle] == key) {
                return middle;
            }
            if (arr[middle] > key) {
                right = middle - 1;
            } else {
                left = middle + 1;
            }
        }
        return -1;
    }
```

* 擴增陣列

```java=
  public static int[] doubleArr(int[] arr) {
        int[] tmpArr = new int[arr.length * 2];
        for (int i = 0; i < arr.length; i++) {
            tmpArr[i] = arr[i];
        }
        return tmpArr;
    }
```
<br>
* 泡泡排序法 (從小到大)
```java=
   public static void bubbleSort(int[] arr, int count) {
        for (int i = 0; i < count - 1; i++) {
            for (int n = 0; n < count - 1 - i; n++) {
                if (arr[n] > arr[n + 1]) {
                    int tmp = arr[n];
                    arr[n] = arr[n + 1];
                    arr[n + 1] = tmp;
                }
            }
        }
    }
```

* 隨機亂數 排列陣列內數值


```java=

    public static void shuffle(int[] arr, int count) {
        for (int i = 0; i < count; i++) {
            int r = (int) (Math.random() * count);
            int tmp = arr[r];
            arr[r] = arr[i];
            arr[i] = tmp;
        }
    }
```

* 移除陣列中某位置的數

```java=
   public static void removeElement(int index, int[] arr, int count) {
        for (int i = index; i < count - 1; i++) {
            arr[i] = arr[i + 1];
        }
    }
```

* 在陣列中指定位置插入 新的數，要記得注意陣列長度

```java=
    public static void insertElement(int value, int index, int[] arr, int count) {
        for (int i = count; i > index; i--) {
            arr[i] = arr[i - 1];
        }
        arr[index] = value;
    }
```


* 最大公因數
```java=
    public static int gcd(int a, int b) {
        
        int r = 0;

        while (b != 0) {
            r = a % b;
            a = b;
            b = r;
        }       
        return a;
    }
```

* 質數搜尋範圍
```java=
public static boolean isPrime(int n) {
        if (n == 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(n); i++) { 
        //搜尋範圍 最簡為n開根號，若有小於開根號 會在之前先被搜尋出來
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }
```



函式用法思考點
重複性的事情，可以寫成函式
功能性單一 針對單一功能為主

例如 判斷質數 則是輸入一個數 回傳 true or false
