编程面试_数组

数组面试题

    笔试和面试中，除了字符串，另一类出现频率极高的问题便是与数组相关的问题。
    解题思路：
    先一般考虑“万能的”暴力穷举（递归、回溯），如求n个数的全排列或八皇后（N皇后问题）。
    但因为穷举时间复杂度通常过高，所以需要考虑更好的方法。

如 分治法（通过分而治之，然后归并）；

以及 空间换时间（如活用哈希表）。

此外，选择合适的 数据结构 可以显著提升效率，如寻找最小的k个数中，用 堆 代替 数组，也可借鉴快排思想，中枢分区方法。

再有，如果题目允许排序，则可以考虑 排序。

寻找和为定值的两个数中，先排序，然后用 前后两个指针 往中间扫描。

    而如果如果已经排好序了（如杨氏矩阵查找中），则想想有无必要二分，二分法。

    但是，如果题目不允许排序呢？这个时候，

我们可以考虑 不改变数列顺序的 贪心算法（如 最小生成树Prim、Kruskal 及 最短路dijkstra）

    或 动态规划（如 01背包问题，每一步都在决策）。

    最后，注意细节处理，不要忽略边界条件，如字符串转换成整数。

基础

int (*p)[10];// 首先(*p)，p是一个指针，int [10],是一个包含10个int的数组，该指针p指向，这个数组
             // 是数组指针
int *p[10];  // 写成 int* p[10];比较合适，首先 [10]是一个包含 10个元素的数组，该元素类型为int*,即指向整形的指针
             // 是指针数组

int a[10];// 整数数组
printf("%x\n",&a);// &a 是取一个数组的地址，是一个指针指向一个包含10个元素的数组，类型为 int (*p)[10];
printf("%x\n",a); // a 数组名，默认为数组首元素 a[0]的地址 和数组a的地址是同一个地址，该类型为指向一个整数的指针，即 int *p；
// 以上 &a 和 a 的值是一样的，是a[0]元素的存储地址，
// 但是含义不一样， &a指向了10个连续存储的整数, 而 a指向了一个 整数，即 a[0]

// 类似的

int (*p[])(int); // 函数指针数组。
// 首先(*p[]) 是一个指针数组，指向的类型为 int (int)是一个函数类型，输入一个int类型参数，输出一个int类型参数

int (*p())[];    // 返回数组指针的函数。
// 首先 (*p()) 是一个返回指针类型的函数，该指针类型指向 int [] 即整形数组，即,p是一个返回整形数组指针的函数

int *p()[]       // 字面上可以解释为返回指针数组的函数，不过函数是不能返回数组的。
// () 是一个函数， 返回类型为 int* []，是一个指针数组

int *(*a())()    // 这是一个函数，它没有参数，它的返回值是一个函数指针，这个指针指向的函数，也没有参数，且返回值是int型的指针。

第一题 寻找集合中的最小的K个数

输入n个整数，输出其中最小的k个。

解法1 先排序再选择

    要求一个序列中最小的k个数，按照惯有的思维方式，
    则是先对这个序列从小到大排序，
    然后输出前面的最小的k个数。
    至于选取什么的排序方法，我想你可能会第一时间想到快速排序
    我们知道，快速排序平均所费时间为n*logn，
    然后再遍历序列中前k个元素输出即可。

因此，总的时间复杂度：O（n * log n)+O(k)=O（n * log n）。

解法2 选择排序思想

解法二

    咱们再进一步想想，题目没有要求最小的k个数有序，也没要求最后n-k个数有序。
    既然如此，就没有必要对所有元素进行排序。这时，咱们想到了用选择或交换排序，即：
    
    1、遍历n个数，把最先遍历到的k个数存入到大小为k的数组中，假设它们即是最小的k个数；
    
    2、对这k个数，利用选择或交换排序找到这k个元素中的最大值kmax（找最大值需要遍历这k个数，时间复杂度为O（k））；
    
    3、继续遍历剩余n-k个数。
       假设每一次遍历到的新的元素的值为x，把x与kmax比较：如果x < kmax ，用x替换kmax，

并回到第二步重新找出k个元素的数组中最大元素kmax‘；如果x >= kmax，则继续遍历不更新数组，直到，k个数是此时最小的
         
每次遍历，更新或不更新数组的所用的时间为O（k）或O（0）。故整趟下来，时间复杂度为nO（k）=O（nk）。

解法3 利用最大堆 作为容器

    更好的办法是维护容量为k的最大堆，原理跟解法二的方法相似：
    
    1、用容量为k的最大堆存储最先遍历到的k个数，同样假设它们即是最小的k个数；
    
    2、堆中元素是有序的，令k1<k2<...<kmax（kmax设为最大堆中的最大元素）
    
    3、遍历剩余n-k个数。
      假设每一次遍历到的新的元素的值为x，把x与堆顶元素kmax比较：
      如果x < kmax，用x替换kmax，然后更新堆（用时logk）；
      否则不更新堆。
    这样下来，总的时间复杂度:O（k+（n-k）*logk）=O（n*logk）。
    此方法得益于堆中进行查找和更新的时间复杂度均为：O(logk)
    （若使用解法二：在数组中找出最大元素，时间复杂度：O（k））。  

解法4 利用快排思想 得到大小数的 分区中枢

    int Cut(int a[], int low, int high){
      int temp = a[low];// 区间第一个元素 可以随机选择 在替换到low的位置
      while(low < high){
        while((low < higt)&&(a[high] > temp)) --high;// 从右边向左寻找比 temp小的元素 a[higt]
        a[low] = a[high];// 把比temp小的元素 放在 原来temp的位置(左边小的区域)
        while((low < high)&&(a[low] < temp))  ++low;// 从左边寻找比 temp大的元素a[low] 放在右边 high的位置
        a[high] = a[low];
       }
      a[low] = temp; // 临时变量 放在 中枢位置
      return low;    // 返回中枢位置
    }

    // 在数组a中选择k个最小的元素  块选  非递归调用
    void QuickSelest(int a[], int low, int high, int k){
      int index =  Cut(a, 0, n-1);// 首先得到一个中枢
      while(index != k-1){// 非递归调用
      if(index > k - 1) index = Cut(a, low, index -1);// 左半部分小的元素个数大于k 在左半部分找 中枢
      else              index = Cut(a, index+1, high);// 左半部分小的元素个数小于k 右半部分还有，在右半部分找 中枢
      }
     // 打印
     for(int i = 0; i<k; ++i) cout<<a[i];
     cout << endl;
    }

    // 而快排为   是递归调用
    void QuickSort(int a[], int low, int high){
      int index;
      if(low < high){
        index = Cut(a, low, high);//选取中枢位置
        QuickSort(a, low, index-1);//对左边快排
        QuickSort(a, index+1, high);//对右边快排
      }
    }

    // 二分查找   非递归版本
    int BinarySearch(int a[], int low, int high, int key){
    int mid;//中间元素
    while(low < high){
    int mid = low + ((high - low)>>1);//中间元素的 下标 在循环体内 不停的被改变
    if( key < a[mid] )     high = mid - 1;// 查找的元素小于中值  高区间移至 mid-1
    elae if(key > a[mid] ) low  = mid + 1;// 查找元素大于中值， 将低区间移至 mid+1
    else return mid;
    }
    return -1;//未找打 返回-1
    }

    // 二分查找   递归版本
    int BinarySearch(int a[], int low, int higt, int key){
    int mid = low + ((high - low)>>1);//中间元素的 下标
    if(low < high){
      if(key < a[mid])      return BinarySearch(a, low, mid-1, key);
      else if(key > a[mid]) return BinarySearch(a, mid+1, high, key);
      else return mid;
    }
    return -1;

}

第二题 寻找和为定值的两个数

    输入一个数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字。
    要求时间复杂度是O(N)。如果有多对数字的和等于输入的数字，输出任意一对即可。
    例如输入数组1、2、4、7、11、15和数字15。由于4+11=15，因此输出4和11。

思路：暴力搜索 时间复杂度 n^2
       其二，二分法（相当于用两个指针），从前后向中间搜索，看情况移动左右指针

代码如下

    // 二分（若无序，先排序后二分），时间复杂度总为O(N log N)，空间复杂度为O（1）；
    void findTwo2(int a[], int low, int high, int sum){
     //sort(a, a+high+1);   如果数组非有序的，那就事先排好序O(N log N)
             while(low < high){
                    if(a[low] + a[high] > sum)      --high;//太大 right减少
                    else if(a[low] + a[high] < sum) ++low; //太小 low增加
                    else cout << a[low] << a[high] < endl;
             }
            cout << "Can't found" < endl;

}

总结

    不论原序列是有序还是无序，解决这类题有以下三种办法：
    1、二分（若无序，先排序后二分），时间复杂度总为O(N log N)，空间复杂度为O（1）；
    2、扫描一遍X-S[i] 映射到一个数组或构造hash表，时间复杂度为O(N)，空间复杂度为O(N)；
    3、两个指针两端扫描（若无序，先排序后扫描），时间复杂度最后为：
       有序O(N)，无序O(N log N + N)=O(N log N)，空间复杂度都为O(1)。
    所以，要想达到时间O(N)，空间O(1)的目标，除非原数组是有序的（指针扫描法），
    不然，当数组无序的话，就只能先排序，后指针扫描法或二分（时间 O(Nlog N)，空间O(1)），
    或映射或hash（时间O(N)，空间O(N)）。时间或空间，必须牺牲一个，达到平衡。
    综上，若是数组有序的情况下，优先考虑两个指针两端扫描法，以达到最佳的时O(N)，空O(1)效应。
    否则，如果要排序的话，时间复杂度最快当然是只能达到O(N log N)，空间O(1)则不在话下。

举一反三：

    输入：int[]nums int target 
    输出：符合要求的所有情况 
    给定一个int类型的数组，sum2、sum3、sum4分别输出2、3、4个元素的和为target的所有结果，不能重复，并且结果从小到大排序。
    【解法】： 
    三个题目均可以使用双指针的做法。首先对原始数组进行排序，排序的意义为：
    （1）保证最后结果的有序性；
    （2）从小到大的查找是否满足target，
    若小于他，则start指针往前走 ++start，
    若大于他，这end指针往回走 --end； 
    接着第一个指针从最小的元素开始，
    第二个指针从最大的元素开始，通过对和与target进行比较，判断start和end的走向。 
    sum2可以不用循环，只需要两个指针。
    同时sum2还可以有另一种解法，从左到右判断，采用一个集合保存判断过的结果，从集合中查找target-nums[i]是否存在；（n） 
    sum3采用一层循环，start从循环处的下一个元素开始（n`2）
    sum4采用两层循环，第二层循环从第一层循环的i值开始，最内部start从第二层循环的下一个元素开始。(n`3) 

第三题 寻找和为定值的多个数

    题目描述

输入两个整数n和sum，从数列1，2，3…n 中随意取几个数，使其和等于sum，要求将其中所有的可能组合列出来。

01背包问题求解

    解法一
    注意到取n，和不取n个区别即可，考虑是否取第n个数的策略，可以转化为一个只和前n-1个数相关的问题。
    如果取第n个数，那么问题就转化为“取前n-1个数使得它们的和为sum-n”，对应的代码语句就是sumOfkNumber(sum - n, n - 1)；
    如果不取第n个数，那么问题就转化为“取前n-1个数使得他们的和为sum”，对应的代码语句为sumOfkNumber(sum, n - 1)。

    0-1背包问题
    0-1背包问题是最基础的背包问题，其具体描述为：
    有N件物品和一个容量为V的背包。放入第i件物品耗费的费用是Ci，得到的价值是Wi。
    求解将哪些物品装入背包可使价值总和最大。
    简单分析下：这是最基础的背包问题，特点是每种物品仅有一件，可以选择放或不放。
    用子问题定义状态：即F[i, v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：
    F[i, v] = max{F[i-1, v], F[i-1, v-Ci ] + Wi}
    根据前面的分析，我们不难理解这个方程的意义：
    “将前i件物品放入容量为v的背包中”这个子问题，若只考虑第i件物品的策略（放或不放），
    那么就可以转化为一个只和前 i-1 件物品相关的问题。
    即：
    如果不放第i件物品，那么问题就转化为“前i-1件物品放入容量为v的背包中”，价值为 F[i-1, v ]；
    如果放第i件物品，那么问题就转化为“前i-1件物品放入剩下的容量为v-Ci的背包中”，
    此时能获得的最大价值就是F[i-1, v-Ci]再加上通过放入第i件物品获得的价值Wi。

    list<int>list1;
    void SumOfkNumber(int sum, int n)
    {
        // 递归出口
        if (n <= 0 || sum <= 0)
            return;
        // 输出找到的结果
        if (sum == n)
        {
            // 反转list
            list1.reverse();
            for (list<int>::iterator iter = list1.begin(); iter != list1.end(); iter++)
                cout << *iter << " + ";
            cout << n << endl;
            list1.reverse()//此处还需反转回来
        }
        list1.push_front(n); //放置进背包 当前占了n 前面剩余sum-n空间  典型的01背包问题
        SumOfkNumber(sum - n, n - 1);//“放”n，前n-1个数“填满”sum-n

        list1.pop_front();// 取出来 不放进去 前面还剩余sum的空间
        SumOfkNumber(sum, n - 1); //不“放”n，n-1个数“填满”sum
    }

第四题 最大连续子数组和

    事实上，当我们令currSum为当前最大子数组的和，maxSum为最后要返回的最大子数组的和，当我们往后扫描时，

    对第j+1个元素有两种选择：要么放入前面找到的子数组，要么做为新子数组的第一个元素；
    
    如果currSum加上当前元素a[j]后不小于a[j]，则令currSum加上a[j]，
    否则currSum重新赋值，置为下一个元素，即currSum = a[j]。
    
    同时，当currSum > maxSum，则更新maxSum = currSum，否则保持原值，不更新。
    即：
    currSum = max(a[j], currSum + a[j])
    maxSum = max(maxSum, currSum)
    举个例子，当输入数组是1, -2, 3, 10, -4, 7, 2, -5，那么，currSum和maxSum相应的变化为：
    currSum： 0 1 -1 3 13 9 16 18 13
    maxSum ： 0 1 1 3 13 13 16 18 18

参考代码如下：
int MaxSubArr(int* a, int num){
int currSum = 0;//初始化 当前和 为0
int maxSum = a[0];//初始化 第一个元素为 最大和
for(int j = 0; j < n; ++j ){
currSum = (currSum + a[j] > a[j] ) ? (currSum + a[j]) : a[j];
maxSum = maxSum > currSum ? maxSum : currSum;
}
return maxSum;
}

第五题 跳台阶问题

    一个台阶总共有n 级，如果一次可以跳1 级，也可以跳2 级。
    求总共有多少总跳法，并分析算法的时间复杂度。

解法一：首先考虑最简单的情况，函数递归调用求解。

    如果只有1级台阶，那显然只有一种跳法。
    如果有2级台阶，那就有两种跳的方法了：
            一种是分两次跳，每次跳1级；
            另外一种就是一次跳2级。
    现在我们再来讨论一般情况。我们把n级台阶时的跳法看成是n的函数，记为f(n)。
    当n>2时，第一次跳的时候就有两种不同的选择：
    一是第一次只跳1级，此时跳法数目等于后面剩下的n-1级台阶的跳法数目，即为f(n-1)；
    另外一种选择是第一次跳2级，此时跳法数目等于后面剩下的n-2级台阶的跳法数目，即为f(n-2)。
    因此n级台阶时的不同跳法的总数f(n)=f(n-1)+f(n-2)。
    我们把上面的分析用一个公式总结如下：
            /  1                             n = 1
    f(n)=      2                             n = 2
            \  f(n-1) + f(n-2)               n > 2
    原来上述问题就是我们平常所熟知的Fibonacci数列问题。

可编写代码，如下：

    longn long Fibonacci(unsigned int n){
    int result[] = [0, 1, 2];
    if (n <= 2)  
            return result[n];
    else 
            return Fibonacci(n-1) + Fibonacci(n-2);
    }

那么，如果一个人上台阶可以一次上1个，2个，或者3个呢？这个时候，公式是这样写的：

            / 1                                      n = 1
    f(n)=     2                                      n = 2
              4                                      n = 3       //111, 12, 21, 3
            \ f(n-1) + f(n-2) + f(n-3)               n > 3

可编写代码，如下：

    longn long F(unsigned int n){
    int result[] = [0, 1, 2, 4];
    if (n <= 3)  
            return result[n];
    else 
            return F(n-1) + F(n-2) + F(n-3);
    }

解法二，循环递推公式求解

解法一用的递归的方法有许多重复计算的工作，事实上，我们可以从后往前推，一步步利用之前计算的结果递推。+
初始化时，dp[0]=dp[1]=1，
然后循环递推计算即可：dp[n] = dp[n-1] + dp[n-2]，当前解 等于前两次的和

参考代码如下：

    // 1,1,2,3,5,8,13,21..
    int ClimbStairs(int n){// n级台阶，可以一次调1个台阶和2个台阶两种选择，有多少种跳发
            int dp[3] = {1, 1};// 保存当前值 上一次值 上上次值的数组
            if(n <=1) return 1;
            else {
                    for(int i = 2; i <= n; ++i){
                            d[2] = d[1] + d[0];
                            d[0] = d[1];
                            d[1] = d[2];// 更新数组的值
                    }
                }
    }

换硬币问题

    // 想兑换100元钱，有1,2,5,10四种钱，问总共有多少兑换方法。 递推公式 arr[j] += arr[j - dimes[i]];
    const int N = 100;
    int dimes[] = { 1, 2, 5, 10 };
    int arr[N + 1] = { 1 };//存放每一个总钱数可以的兑换次数
    int coinExchange(int n)   //非递归实现       
    {
            for (int i = 0; i < sizeof(dimes) / sizeof(int); ++i)//对于每一个面值
            {
                for (int j = dimes[i]; j <= n; ++j)// 遍历总钱数j ~ n
                {
                    arr[j] = arr[j] + arr[j - dimes[i]];
                    //分为两种情况，
                    //总钱数j，如果没有换当前硬币i，那么是多少？arr[j]
                    //加上，如果换了当前硬币dimes[i]，总值减少为 j-dimes[i]，此时又是多少种兑换方法？arr[j-dimes[i]]
                }
            }
            return arr[n];
    }

奇偶调序

    输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。要求时间复杂度为O(n)。

方法1 利用快排思想 奇偶数分类下标 头指针，向右移动 尾指针，向左移动

    借鉴partition 分治 的实现一，我们可以考虑维护两个指针，
    一个指针指向数组的第一个数字，我们称之为头指针，向右移动；
    一个指针指向最后一个数字，称之为尾指针，向左移动。

    这样，两个指针分别从数组的头部和尾部向数组的中间移动，
    如果第一个指针指向的数字是偶数而
    第二个指针指向的数字是奇数，我们就交换这两个数字。
    因为按照题目要求，最终是为了让奇数排在数组的前面，偶数排在数组的后面，
    所以头指针理应指向的就是奇数，尾指针理应指向的就是偶数，

故当头指针指向的是偶数且尾指针指向的是奇数时，我们就当立即交换它们所指向的数字。

代码实现：

    // 判断是否为奇数
    bool isOddNumber(int n){
    return n & 1 == 1; // 奇数 的最后一个二进制位为1
    }
    
    // void OddEvenChange(int *a, int num){
            if(a == NULL|| num == 0) return;// 空指针 以及长度为0 直接返回
            int* low  = a;           // 头指针
            int* high = a + num - 1; // 尾指针
            while(low < high){
                    if(!isOddNumber(*high) --high;//如果 high指针指向的是偶数，正常，向前移 减小
                    else if(isOddNumber(*low) ++low;//如果 low指针指向的是奇数，正常，向后移 加大
                    else //否则都不正常，交换
                    //swap是STL库函数，声明为void swap(int& a, int& b);
                    swap(*pBegin, *pEnd);
            }
    }

本方法通过头尾两个指针往中间扫描，一次遍历完成所有奇数偶数的重新排列，时间复杂度为O(n)。

荷兰旗 三色球 问题  三类的分配问题

    现有n个红白蓝三种不同颜色的小球，乱序排列在一起，请通过两两交换任意两个球，
    使得从左至右，依次是一些红球(类1)、一些白球(类2)、一些蓝球(类3)。

    通过前面的分析得知，这个问题类似快排中partition过程，只是需要用到三个指针：
    一个前指针begin(指向类1)，一个中指针current(指向类2)，一个后指针end(指向类3)，
    current指针遍历整个数组序列，当:
    current指针所指元素为 类1 时，与begin指针所指的元素交换，而后current++，begin++ ；
    current指针所指元素为 类2 时，不做任何交换（即球不动）， 而后current++ ；
    current指针所指元素为 类3 时，与end指针所指的元素交换，  而后，current指针不动(end指向的元素可能为类1 )，end-- 。

参考代码如下：

    while( current<=end )        
    {             
      if( array[current] ==0 )             
       {                 
          swap(array[current],array[begin]);                  
          current++;                  
          begin++;            
       }             
       else if( array[current] == 1 )            
       {                 
          current++;            
       }   

       else //When array[current] =2   
       {               
          swap(array[current],array[end]);                
          end--;            
       }      
    }