笔试题目练习1

时间复杂度练习题

1. 给定一个整数sum，从有N个有序元素的数组中寻找元素a，b，使得a+b的结果最接近sum，最快的平均时间复杂度是（ ）

• A O(n)

• B.O(n^2)

• C.O(nlogn)

• D.O(logn)

答案：A

解析：此题目中，数组元素有序，所以a,b两个数可以分别从开始和结尾处开始搜，根据首尾元素的和是否大于sum,决定搜索的移动，整个数组被搜索一遍，就可以得到结果，所以最好时间复杂度为n

2. 设某算法的递推公式是T(n)=T(n-1)+n，T(0)=1，则求该算法中第n项的时间复杂度为（）

• A.O(n)

• B.O(n^2)

• C.O(nlogn)

• D.O(logn)

答案：A

**解析：**T(n)

=T(n-1)+n

=T(n-2)+(n-1)+n

=T(n-3)+(n-2)+(n-1)+n

…

=T(0)+1+2+…+(n-2)+(n-1)+n

=1+1+2+…+(n-2)+(n-1)+n

从递推公式中可以看到，第n项的值需要从n-1开始递归，一直递归到0次结束，共递归了n-1次所以时间复杂度为n

3. 分析以下函数的时间复杂度

   void fun(int n) {
     int i=l;
     while(i<=n)
       i=i*2;
   }
   

• A.O(n)

• B.O(n^2)

• C.O(nlogn)

• D.O(logn)

答案：D

解析: 此函数有一个循环，但是循环没有被执行n次，i每次都是2倍进行递增，所以循环只会被执行log2(n)次

4. 如果一个函数的内部中只定义了一个二维数组a[3][6]，请问这个函数的空间复杂度为（ ）

   • A.O(n)

   • B.O(n^2)

   • C.O( 1 )

   • D.O(m*n)

答案：C

解析：函数内部数组的大小是固定的，不论函数运行多少次，所需空间都是固定大小的，因此空间复杂度为O(1)

5. 分析以下函数的空间复杂度

   public static int[][] get2Array(int n){
       int[][] array = new int[n][];
       for(int i = 0; i < n; i++) {
           array[i] = new int[n-i];
           n--;
       }
   
       return array;
   }
   

   • A.O(1)

   • B.O(N)

   • C.O(N^2)

   • D.O(logN)

答案：C

该函数的作用是创建一个倒三角的二维数组：

第0行n个int的空间

第1行n-1个int的空间

第2行n-2个int的空间

…

第n-1行1个元素的空间

空间总的个数为：1+2+3+…+N-1 + N + N = (1+N)*N/2 + N = N^2/2 + 3N/2

采用大O渐进发表示就是：O(N^2)

面试题 17.04. 消失的数字

class Solution {
    /*
    解题思路：
    直接将数组中所有元素之和sum，然后求出1~N的前N项和-sum即可
    时间复杂度O(N)，空间复杂度:O(1)
    缺陷：如果数组中元素比较多，相加完成之后容易溢出
     */
    public int missingNumber1(int[] nums) {
        int sum = 0;
        for(int i = 0; i < nums.length; ++i){
            sum += nums[i];
        }


        return ((1+nums.length)*nums.length)/2 - sum;
    }

    /*
        解题思路：
          采用异或的方式解决，因为两个相同的数字异或的结果是0
          因此：将0~N之间的数字，与数组中的每个数字异或，
                最终的结果就是丢失的数字
     */
    public int missingNumber2(int[] nums) {
        int data = 0;
        for(int i = 0; i < nums.length; ++i){
            data ^= nums[i];
            data ^= i;
        }
        data ^= nums.length;
        return data;
    }

    /*
        解题思路：
        将1~N之间的数组相加，然后减去nums数组中的每个数字
     */
    public int missingNumber(int[] nums) {
        int data = nums.length;
        for(int i = 0; i < nums.length; ++i){
            data = data - nums[i] + i;
        }
        return data;
    }
}

189. 轮转数组 - 力扣（LeetCode）

/*
    解题思路：
    按照题目所说，进行k次旋转，每次旋转移动一个字符
    注意：k如果超过nums的长度时，对k取模
    时间复杂度: O(KN)
    思路没有问题，但是会时间复杂度会超
*/
/*
class Solution {
    public void rotate(int[] nums, int k) {
        k %= nums.length;
        for(int i = 0; i < k; ++i){
            // 将数组中前n-1个元素整体往后搬移一个位置
            int last = nums[nums.length-1];
            for(int j = nums.length-1; j >= 1; --j){
                nums[j] = nums[j-1];
            }
            // 将搬移前最后一个元素放到数组0号位置
            nums[0] = last;
        }
    }
}
*/

/*
  解题思路：使用三次逆转法，让数组旋转k次
    1. 整体逆置 
    2. 逆转子数组[0, k - 1]
    3. 逆转子数组[k, size - 1]
*/
class Solution {
    void rotate(int[] nums, int left, int right){
        while(left < right){
            int temp = nums[left];
            nums[left] = nums[right];
            nums[right] = temp;
            left++;
            right--;
        }
    }
    public void rotate(int[] nums, int k) {
        k %= nums.length;
        rotate(nums, 0, nums.length-1);
        rotate(nums, 0, k-1);
        rotate(nums, k, nums.length-1);
    }
}