数据结构练习题——Java实现

20240531-时间复杂度

1、消失的数字

方法一：位运算

两个数字一样的数组，其中一个数组中少了一个数字，定义一个变量分别异或两个数组，结果即为缺少的数字

    class Solution {
        public int missingNumber(int[] nums) {
            int xor = 0;
            int n = nums.length;//获取数组长度
            for (int i = 0; i < n; i++) {//因为该数组少一个数，所以i < n
                xor ^= nums[i];
            }
            for (int i = 0; i <= n; i++) {//假设该数组数字为0~n，不少数字，所以i <= n
                xor ^= i;
            }
            //分别遍历两数组进行异或操作，相同数字异或得零
            //其他数字均出现两次，只有一个数字出现一次
            return xor;
        }
    }

方法二：数学规律

1到n的等差数列的总和，减去当前数组元素的总和，即为缺少的数字

class Solution {
   public int missingNumber(int[] nums) {
       int n = nums.length;
       //等差数列总和 = （首项 + 尾项）* 项数 / 2
       int total = (1 + n) * n / 2;
       //当前数组的总和
       int sum = 0;
       for(int i=0;i<n;i++){
           sum += nums[i];
       }
       //缺少值 = 等差数列总和 - 数组总和
       return total - sum;
   }
}

 2、旋转数组

这个不会，暂且搁置

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

A.O(n)

B.O(n^2)

C.O(nlogn)

D.O(logn)

选B了

解析：

正确答案A，数组元素有序，所以a，b两个数可以分别从开始和结尾处开始搜索，根据首位元素的和是否大于sum，决定搜索的移动，整个数组被搜索一遍，就可以得到结果，所以时间复杂度为O(n)

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

A.O(n)

B.O(n^2)

C.O(nlogn)

D.O(logn)

解析：

5、分析以下函数的时间复杂度

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倍进行递增，所以只会被执行

6、分析以下函数的空间复杂度

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)

解析：

20240320-包装类

7、移除元素

思路一：双指针

如果要移除的元素恰好在数组的开头，例如序列 [1,2,3,4,5]，当 val 为 1 时，我们需要把每一个元素都左移一位。注意到题目中说：「元素的顺序可以改变」。实际上我们可以直接将最后一个元素 5 移动到序列开头，取代元素 1，得到序列 [5,2,3,4]，同样满足题目要求。这个优化在序列中 val 元素的数量较少时非常有效。

实现方面，我们使用双指针，两个指针初始时分别位于数组的首尾，向中间移动遍历该序列。

算法：

如果左指针 left 指向的元素等于 val，此时将右指针 right 指向的元素复制到左指针 left 的位置，然后右指针 right左移一位。如果赋值过来的元素恰好也等于 val，可以继续把右指针 right 指向的元素的值赋值过来（左指针 left 指向的等于 val 的元素的位置继续被覆盖），直到左指针指向的元素的值不等于 val 为止。

当左指针 leftt 和右指针 right 重合的时候，左右指针遍历完数组中所有的元素。

这样的方法两个指针在最坏的情况下合起来只遍历了数组一次。

    public static int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length;
        while(left < right) {
            if(nums[left] == val) {
                nums[left] = nums[right-1];
                right--;
            }else {
                left++;
            }
        }
        return left;
    }

解析：

 

思路二：

class Solution {
   public int removeElement(int[] nums, int val) {
       int count = 0;
       for (int n : nums) {
           if (n == val) {
               continue;
           }
           nums[count++] = n;//此处后置++很重要
       }
       return count;
   }
}

8、删除有序数组中的重复项

//自己写的
class Solution {
    public int removeDuplicates(int[] nums) {
        int left = 0;
        int right = 1;
        while(right != nums.length) {
            if(nums[left] == nums[right]){
                right++;
            }else {
                nums[left+1] = nums[right];
                left++;
                right++;
            }
        }
        return left+1;
    }
}

//题解
class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        int fast = 1, slow = 1;
        while (fast < n) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }
}

9、合并两个有序数组

方法一：直接合并后排序，该方法没有利用到题目中nums1和nums2已被排序的性质

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        for (int i = 0; i != n; ++i) {
            nums1[m + i] = nums2[i];
        }
        Arrays.sort(nums1);
    }
}

方法二：双指针

    //该方法创建一个新数组sorted，将nums1和nums2中数据逐个比较，按照非降序添加到sorted数组中，最后将该数组元素逐个覆盖到nums1中
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = 0, p2 = 0;
        int[] sorted = new int[m + n];
        int cur;//用来存放两数组中较小值，是一个中间变量
        while (p1 < m || p2 < n) {//循环结束条件为两数组均遍历完成
            if (p1 == m) {//当nums1数组中的有效数组遍历完成后，将剩余nums2中元素逐个添加到sorted中
                cur = nums2[p2++];
            } else if (p2 == n) {//当nums2数组中的有效数组遍历完成后，将剩余nums1中元素逐个添加到sorted中
                cur = nums1[p1++];
            } else if (nums1[p1] < nums2[p2]) {//当nums1中p1下标值小于nums2中p2下标值，将p1下标值添加到sorted
                cur = nums1[p1++];
            } else {
                cur = nums2[p2++];
            }
            sorted[p1 + p2 - 1] = cur;//将cur存储的值添加到sorted的相应位置
        }
        for (int i = 0; i != m + n; ++i) {//将该数组元素逐个覆盖到nums1中
            nums1[i] = sorted[i];
        }
    }

方法三：逆向双指针

    //逆向双指针
    //两指针分别定义在数组尾部，比较大小，将较大的放于nums1.length-1处
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = m-1;//这是nums1中有效数据的个数
        int p2 = n-1;
        int tail = nums1.length-1;//这时nums1数组长度，与p1区分
        while(p1 >= 0 && p2 >= 0) {
            if(nums1[p1] > nums2[p2]) {
                nums1[tail--] = nums1[p1--];
            }else {
                nums1[tail--] = nums2[p2--];
            }
        }
        while(p2 >= 0) {//若p1已遍历完，将p2中剩余数值直接覆盖到nums1中即可
            nums1[tail--] = nums2[p2--];
        }
    }