# 数组的常见算法
    - 查找算法
       1. 基本查找/顺序查找
       2. 二分查找/折半查找
       3. 插值查找
       4. 分块查找
       5. 哈希查找
       6. 树表查找
       7. 斐波那契查找
       
    - 排序算法（顾名思义，就是把没有顺序的数据进行从小到大/从大到小排序）
       1. 冒泡排序
       2. 选择排序


## 基本查找/顺序查找
        - 核心思路：就是从数组的0索引开始，依次往后查找
           * 如果找到了，就会返回数据对应的索引
           * 如果没找到，就会返回-1

    #include<stdio.h>
    int order(int arr[], int len, int needFindNum) {
        for (int i = 0; i < len; i++)
        {
            if (arr[i] == needFindNum)
            {
                return i;
            }
        }
        return -1;
    }

    int main() {
        //1. 定义数组
        int arr[] = {11,22,33,44,55};
        int len = sizeof(arr) / sizeof(arr[0]);
        //2. 定义一个变量表示要查找的数据
        int num = 55;
        //3. main函数外定义一个方法进行顺序查找
        int index = order(arr,len,num);
        printf("%d\n", index);
        return 0;
    }

## 二分查找/折半查找
        - 前提条件：数组里得数据必须是有序的
        - 核心逻辑：每次排除一半的查找范围
        - 默认刚开始min是索引为0的值，max是索引为最大的那个值
        - 核心思路：
           1. min和max表示当前要查找的范围
           2. min是min和max中间的
           3. 如果要查找的值在mid的左边，缩小范围时，min不变，max等于mid - 1
           4. 如果要查找的值在mid的右边，缩小范围时，max不变，min等于mid + 1
             * 如果找到了，就会返回数据对应的索引
             * 如果没找到，就会返回-1

 #include<stdio.h>
    int binarySearch(int arr[], int len, int needFindNum) {
        //1确定要查找的范围
        int min = 0;
        int max = len - 1;//注意min,max,mid都是指索引
        while (min <= max) {
            int mid = min + (max - min)/ 2;//确定中间位置
            if (arr[mid] < needFindNum)
            {
                min = mid + 1;
            }
            else if (arr[mid] > needFindNum)
            {
                max = mid - 1;
            }
            else {
                return mid;
            }
        }
        return -1;
        }

        int main() {
        //折半查找/二分查找
        int arr[] = {11,22,33,44,55};
        int len = sizeof(arr) / sizeof(arr[0]);
        int num = 33;
        int index = binarySearch(arr, len, num);
        printf("要查找的值所在索引为：%d\n",index);
        return 0;
    }

## 插值查找
        - 要求：数据要有序，且数据分布尽可能得均匀分布一些
        - 优势：满足要求，效率比二分查找快，否则反而会更慢。
        - 和二分查找相比，mid尽可能得靠近要查找的数据，但是要求数据尽可能的分布均匀。
        - 代码和二分查找无异，就是把mid = (min + max)/2;  替换成：
       int mid = min + (needFindNum - arr[min]) / (arr[max] - arr[min]) * (max - min);


## 分块查找
        - 分块的原则1：前一块中的最大数据，小于后一块中所有的数据（块内无序，快间有序）
        - 分块的原则2：块数数量一般等于数字的个数开根号，比如：16个数字一般分为4块左右
        - 核心思路：先确定要查找的元素在哪一块，然后块内挨个查找
         * 面对无规律的数据，在进行分块时，确保每块数字无交集（哈希查找）


## 哈希查找
        - 在分块查找的核心思路上，面对的是无规律的数据，在进行分块时，确保每块数字无交集


## 冒泡排序
        - 核心逻辑：相邻的数据两两比较，小的放前面，大的放后面
        - 核心思路：
             1. 相邻的元素两两比较，大的放右边，小的放左边。（默认排成从小到大）
             2. 第一轮比较完毕之后，最大值就已经确定，第二轮以此类推。
             3. 如果数据中有n个数据，总共我们只要执行n-1轮的代码就可以了
  

#include<stdio.h>
        void bubbleSort(int arr[] , int len) {
            for (int j = 0; j < len - 1; j++)
            {
                for (int i = 0; i < len - 1 - j; i++) {
                    if (arr[i] > arr[i+1])
                    {
                        int temp = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = temp;
                    }
                }
            }
        }

        int main() {
            int arr[] = {55,56,33,11,22};
            int len = sizeof(arr) / sizeof(arr[0]);
            bubbleSort(arr, len);
            //遍历排完序后的数组
            for (int i = 0; i < len; i++)
            {
                printf("%d ",arr[i]);
            }
            return 0;
        }

## 选择排序
        - 核心逻辑：从0索引开始，拿着每一个索引上的元素跟后面的元素依次比较，小的放前面，大的放后面，以此类推。
        - 核心思想：
          1. 从0索引开始，跟后面的元素进行一一比较
          2. 小的放前面，大的放后面
          3. 第一轮循环从0索引开始比较，结束后最小的数据已经确定
          4. 第二轮……以此类推
      

 #include<stdio.h>
        void selectSort(int arr[] ,int len) {
            for (int j = 0; j < len - 1; j++)
            {
                for (int i = j + 1; i < len ;i++) {
                    if (arr[j] > arr[i])
                    {
                        int temp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                    }
                }
           }
        }

       int main() {
            int arr[] = { 55,56,33,11,22 };
            int len = sizeof(arr) / sizeof(arr[0]);
            selectSort(arr,len);
            //遍历排好序的数组
            for (int i = 0; i < len; i++)
            {
                printf("%d ",arr[i]);
            }
           return 0;
        }