leetcode 303

leetcode 303

题目

例子

思路

使用数组存储[0, i] 的vals 值之和， sum[i] 表示 第0个元素到第(i-1)个元素之和。

代码

class NumArray {
    vector<int> sum;
public:
    NumArray(vector<int>& nums) {
        int n = nums.size();
        sum.resize(n+1);
        
        for(int i=0; i<n; i++){
            sum[i+1] = sum[i] + nums[i];
        }
    }
    
    int sumRange(int left, int right) {
        
        return sum[right+1] - sum[left];
     
    }
};

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray* obj = new NumArray(nums);
 * int param_1 = obj->sumRange(left,right);
 */

介绍深拷贝和浅拷贝

深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是在编程中常用的两个概念，用于描述在复制对象或数据结构时发生的不同方式。以下是它们的区别：

1. 浅拷贝（Shallow Copy）：
   浅拷贝是指将一个对象的值复制到另一个对象，但只复制对象本身，而不复制对象引用的内容。因此，新对象和原始对象引用相同的内存地址，如果原始对象中包含指向其他对象的指针或引用，浅拷贝后的对象仍然会共享这些指针或引用。这可能导致多个对象共享相同的资源，当一个对象修改资源时，会影响到其他对象。

2. 深拷贝（Deep Copy）：
   深拷贝是指将一个对象的值复制到另一个对象，同时也复制对象引用的内容。这意味着新对象和原始对象引用不同的内存地址，且它们的内容是完全独立的。深拷贝会递归地复制对象的所有内容，包括嵌套对象、指针指向的对象等。因此，即使一个对象被修改，不会影响到另一个对象。

在编程中，深拷贝通常需要额外的内存和时间开销，因为需要复制整个对象及其所有嵌套内容。而浅拷贝则更为高效，但可能会导致意外的行为，特别是在多个对象共享同一资源时。

在设计程序时，需要根据需求和情况选择适合的拷贝方式。如果需要独立的对象副本，应该使用深拷贝；如果只是需要共享数据，可以使用浅拷贝。在C++中，通过重载拷贝构造函数和赋值运算符可以实现深拷贝。

浅拷贝和深拷贝的区分：

1. 内存管理：浅拷贝只是简单地复制指针，使得新对象和原对象共享同一块内存空间，而深拷贝会为新对象分配新的内存空间，并将原对象的数据复制到新的内存空间中。

2. 析构函数：深拷贝通常会定义自己的析构函数来释放动态分配的内存，确保在对象被销毁时内存得到正确释放，而浅拷贝可能会导致内存泄漏或悬挂指针的问题。

3. 拷贝构造函数：深拷贝会在拷贝构造函数中进行数据的深度复制，而浅拷贝只是简单地复制指针，导致新旧对象共享同一内存地址。

4. 赋值运算符重载：深拷贝通常会重载赋值运算符 =，以确保在对象赋值时进行深度复制，而浅拷贝可能会导致赋值后的对象共享数据。

5. 数据的独立性：通过修改一个对象的数据，观察另一个对象的数据是否受影响，如果受影响则是浅拷贝，如果不受影响则是深拷贝。

浅拷贝例子

以下是一个简单的示例，展示了浅拷贝的概念和效果：

#include <iostream>
#include <vector>

using namespace std;

class MyClass {
public:
    int* data;

    // 构造函数
    MyClass(int value) {
        data = new int(value);
    }

    // 拷贝构造函数（浅拷贝）
    MyClass(const MyClass& other) {
        data = other.data; // 浅拷贝，共享同一内存地址
    }

    // 析构函数
    ~MyClass() {
        delete data;
    }
};

int main() {
    // 创建对象 a
    MyClass a(5);

    // 浅拷贝对象 a 到对象 b
    MyClass b = a;

    // 修改对象 b 的值
    *(b.data) = 10;

    // 输出对象 a 和对象 b 的值
    cout << "a.data: " << *(a.data) << endl; // 输出 10，因为对象 a 和对象 b 共享同一内存地址
    cout << "b.data: " << *(b.data) << endl; // 输出 10

    return 0;
}

在上面的示例中，我们定义了一个名为 MyClass 的类，其中包含一个指向整数的指针 data。在拷贝构造函数中，我们进行了浅拷贝，即将对象 other 的 data 指针赋值给当前对象的 data 指针，导致两个对象共享同一内存地址。

在 main 函数中，我们创建了对象 a，然后通过浅拷贝将其复制到对象 b。当我们修改对象 b 的值时，对象 a 的值也被修改，因为它们共享同一内存地址。这就是浅拷贝的效果，可能导致意外的行为和数据共享问题。

深拷贝

以下是一个简单的示例，展示了深拷贝的概念和效果：

#include <iostream>

class MyArray {
private:
    int size;
    int* data;

public:
    // 构造函数
    MyArray(int s) : size(s), data(new int[s]) {}

    // 拷贝构造函数（深拷贝）
    MyArray(const MyArray& other) : size(other.size), data(new int[other.size]) {
        for (int i = 0; i < size; i++) {
            data[i] = other.data[i];
        }
    }

    // 析构函数
    ~MyArray() {
        delete[] data;
    }

    // 打印数组元素
    void print() {
        for (int i = 0; i < size; i++) {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    // 创建对象 a
    MyArray a(5);
    for (int i = 0; i < 5; i++) {
        a.data[i] = i + 1;
    }

    // 深拷贝对象 a 到对象 b
    MyArray b = a;

    // 修改对象 b 的值
    b.data[0] = 10;

    // 输出对象 a 和对象 b 的值
    std::cout << "a: ";
    a.print(); // 输出 1 2 3 4 5
    std::cout << "b: ";
    b.print(); // 输出 10 2 3 4 5

    return 0;
}

在上面的示例中，我们定义了一个名为 MyArray 的类，其中包含一个整数大小和一个指向整数数组的指针 data。在拷贝构造函数中，我们进行了深拷贝，即为新对象分配了新的内存空间，并将原对象的数据复制到新的内存空间中，从而避免了数据共享问题。

在 main 函数中，我们创建了对象 a，并为其数组赋值。然后通过深拷贝将对象 a 复制到对象 b。当我们修改对象 b 的值时，对象 a 的值不会受到影响，因为它们拥有各自独立的内存空间。