C语言中，定义数组后可以用sizeof命令获得数组的长度（可容纳元素个数），通过数组占内存总空间/单个元素占内存空间大小，即可得到数组的元素个数
例如

int arr[] = {10, 30, 20, 11, 22, 19, 20, 10, 222, 17};
int length = sizeof(arr) / sizeof(arr[0]);  //数组占内存总空间，除以单个元素占内存空间大小

但是，通过将数组作为函数参数传递到函数中，以获得数组长度是不可行的
例如

int getLength(int arr[]) {
    int length = sizeof(arr) / sizeof(arr[0]);
    return length;
}

原因：数组arr是函数参数，在函数中，arr只是一个指针（地址，系统在本函数运行时，是不知道arr所表示的地址有多大的数据存储空间，这里只是告诉函数：一个数据存储空间首地址），所以，sizoef(arr)的结果是指针变量arr占内存的大小，一般在32位机上是4个字节。arr[0]是int类型，sizeof(arr[0])也是4个字节，所以，结果永远是1。

如果想要在被调用的函数中，得知原数组的大小，可以再给函数添加一个参数，用于指定数组的大小，让外界调用函数前就讲数组的大小传递进来

void bubbleSort(int arr[], int length);
int binaryChop(int arr[], int target, int length);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int arr[] = {10, 30, 20, 11, 22, 19, 20, 10, 222, 17};
        
        int length = sizeof(arr) / sizeof(arr[0]);  //数组占内存总空间，除以单个元素占内存空间大小
        
        bubbleSort(arr, length);
        
        for (int i = 0; i < length; ++i) {
            NSLog(@"%d", arr[i]);
        }
        
        
        int targetIndex = binaryChop(arr, 20, length);
        NSLog(@"目标索引值为:%d", targetIndex);
        
    }
    return 0;
}


// 冒泡排序， length是数组的元素个数
void bubbleSort(int arr[], int length) {

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

// 二分查找法，前提数组必须排好序的情况下
int binaryChop(int arr[], int target, int length) {

    // 定义三个变量，一个保存最大元素索引，一个保存最小元素索引，一个保存中间元素索引
    int maxIndex = length - 1;
    int minIndex = 0;
    int middleIndex = (maxIndex + minIndex) * 0.5;
    
    while (true) {
        if (target > arr[middleIndex]) {
            minIndex = middleIndex + 1;
        } else if (target < arr[maxIndex]) {
            maxIndex = middleIndex - 1;
        } else {
            // 找到了就返回
            return middleIndex;
        }
        
        // 重新计算中间索引值
        middleIndex = (maxIndex + minIndex) * 0.5;
        
        // 找不到
        if (minIndex > maxIndex) {
            return -1;
        }
    }
}