力扣最长公共前缀-14

最长公共前缀-14

cpp 复制代码

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        //定义一个字符数组，用于存储strs字符串数组第一个字符串，方便与后面的字符串进行比较判断
        char s[200];
        //定义一个字符数组，用来返回结果
        char c[200];
        /*如果只有一个strs数组中只有一个字符串的情况下，这个字符串即为最长前缀
        直接将字符串的元素赋值到字符数组中然后返回字符数组*/
        if(strs.size()==1){
            for(int f=0;f<strs[0].length(); f++){
                c[f] = strs[0][f];
            }
            return c;
        }
        /*定义四个整形变量
        temp：temp用来存放第一个字符串与当前字符串中的每个字符进行比较，某个位置字符不相同时的位置，也表示当前公共前缀的长度
        Min：Min用来存储最短的前缀
        len：len表示每个字符串的长度
        flag：flag用来标记*/
        int temp = 0, Min = 205, len = 0, flag = 0;
        /*先将strs第一个字符串数组的第一个字符串中每个字符赋值到字符数组s中（s[i] = strs[0][i];），
        循环结束后++len为第一个字符串的长度*/
        for (int i = 0; i < strs[0].length(); i++) {
            s[i] = strs[0][i];
            ++len;
        }
        //循环遍历字符数组中的每个字符串
        for (int i = 1; i < strs.size(); i++) {
        /*if判断用来判断第一个字符串是否小于当前字符串的长度，
        如果第一个字符串小于当前字符串的长度就将len更新为当前字符串的长度，防止遍历时遗漏字符*/
            if (len < strs[i].length())
			len = strs[i].length();
        //循环遍历字符数组中的当前字符串的每个字符，并于第一个字符串进行比较
            for (int j = 0; j < len; j++) {
        //如果某个字符串与第一个字符串(s字符数组)中的第一个字符不同，则strs字符串数组中没用公共前缀，直接返回""
                if(s[0]!=strs[i][0])return "";
        /*当遍历到当前字符与第一个字符中的字符不同时，则用temp记录当前位置（也是前缀的长度），
        然后利用min找最短公共前缀，将最短前缀存储到Min中，将flag置为1是用来防止每个字符串都相同的情况，
        最后结束当前字符串的遍历（break）*/
                if (s[j] != strs[i][j]) {
                    temp = j;
                    Min = min(Min,temp);
                    flag = 1;
                    break;
                }
            }
        }
        /*如果以上双层for循环结束后flag仍然为0，说明所有字符串都相同，直接将Min赋值为第一个字符串的长度即可
        如果没有flag标记，所有字符串都相同的情况下，Min的值为0，无法进行后续操作。*/
        if(flag == 0)Min = len;
        //最后将字符数组中最后一个字符串的最短前缀赋值到用来存储结果的字符数组c中，返回字符数组c;
        for (int k = 0; k < Min; k++) {
            c[k] = strs[strs.size() - 1][k];
        }
        return c;
    }
};

每日问题

什么是虚拟内存，为什么要使用虚拟内存，虚拟内存可能比物理内存大吗

1.什么是虚拟内存？

虚拟内存是计算机系统内存管理的一种技术。它在操作系统的支持下，使用硬盘空间来模拟内存，为每个进程提供一个独立的、连续的虚拟地址空间。

从进程的角度来看，它"认为"自己拥有连续的内存空间，这些地址被称为虚拟地址。当进程访问内存时，它使用的是虚拟地址，而操作系统会通过一种叫做内存管理单元（MMU）的硬件设备和相关的软件机制，将虚拟地址转换为物理地址，从而访问实际的物理内存或者硬盘上的交换空间（如果物理内存不足）。

例如，在32位的操作系统中，每个进程通常由4GB的虚拟地址空间（2的32次方字节），这是一个很大的地址范围，给进程一种它拥有大量内存的错觉。

2.为什么要使用虚拟内存

程序隔离与保护

每个进程都有自己独立的虚拟地址空间，这使得多个进程可以同时运行而不会干扰。例如，一个进程中的程序错误（如指针越界）通常不会影响到其他进程的内存空间，因为每个进程看到的是自己独立的虚拟内存。这就像每个家庭内部出现问题（程序错误），也不会轻易影响到其他家庭（其他进程）。

内存利用效率的提升

程序在运行时，并不是所有的代码和数据都需要同时在物理内存中。虚拟内存允许将暂时不使用的部分程序代码和数据存储到磁盘上的交换空间，而只在需要的时候将其调入物理内存。这就好比一个图书馆（磁盘）有大量的藏书（程序代码和数据），但阅览室（物理内存）空间有限，管理员（操作系统）可以根据读者（进程）的需求，将需要阅读的书（代码和数据）从图书馆搬到阅览室，不需要的放回图书馆，从而更高效地利用有限的物理内存资源。

支持更大的程序运行

虚拟内存可以为进程提供比实际物理内存更大的地址空间。这使得可以运行那些理论上需要比物理内存容量还大的内存空间的程序。例如，一些大型的图形处理软件或者数据库系统，它们可能需要处理大量的数据，如果没有虚拟内存，这些程序可能因为物理内存不足而无法运行。

3.虚拟内存可能比物理内存大吗

是的，虚拟内存可以比物理内存大。如前面所述，在32位操作系统下，每个进程通常有4GB的虚拟地址空间，而实际的物理内存可能远小于这个值。

当物理内存不足时，操作系统会将一部分暂时不使用的内存数据交换到磁盘上的交换空间（也称未页面文件），这个交换空间是虚拟内存的一部分。通过这种方式，从进程的角度来看，它仍然可以访问到比物理内存更多的内存空间，只是访问磁盘上的交换空间会比访问物理内存慢很多。

例如一台计算机有 8GB 的物理内存，但通过设置适当的虚拟内存（包括磁盘上的交换空间），可以让进程认为它们拥有比 8GB 大得多的内存空间，从而能够运行那些对内存需求较大的程序。不过，过度依赖磁盘交换空间会导致性能下降，因为磁盘 I/O 速度比内存访问速度慢很多。

C++函数的返回值在内存中的传递过程是什么

1.基本数据类型返回值的传递

寄存器传递（常见的优化方式）

在现代编译器优化下，对于像int、double等基本数据类型的返回值，编译器通常会优先尝试使用寄存器来传递。例如，在x86架构中，EAX寄存器常用于返回int类型的值。当一个函数返回一个int类型的值时，函数体计算出这个值后，会将其存储到EAX寄存器中。

例如，有一个简单的函数int add(int a,int b){ return a + b;}，当这个函数执行return a + a;语句时，a+b的结果会被放入EAX寄存器，然后函数返回。调用这个函数的代码可以直接从EAX寄存器获取返回值。

栈传递（没有优化的情况）

如果编译器没有进行寄存器传递的优化，或者由于某些特殊情况（如寄存器资源紧张等），基本数据类型的返回值也可能通过栈来传递。

函数会在栈上预留一个空间来存储返回值。当执行return语句时，计算得到的返回值会被复制到这个栈空间中。调用函数会从这个栈空间中获取返回值。这种方式相对寄存器来说，速度会慢一些，因为访问栈内存比访问寄存器要慢。

2.对象（类类型）返回值的传递

拷贝构造函数参与的传递（无返回值优化）

当函数返回一个对象时，在没有返回值优化（RVO，Return Value Optimization）的情况下，会涉及到拷贝构造函数。假设我们有一个类MyClass，定义如下：

cpp 复制代码

class MyClass {
public:
  MyClass() {}
  MyClass(const MyClass& other) {
    // 拷贝构造函数的实现，用于复制对象的成员
  }
};

当函数MyClass getObject(){MyClass obj: return obj;}被调用时，在函数内部创建了一个MyClass对象obj。当执行return语句时，会调用MyClass的拷贝构造函数来创建一个新对象，这个新对象是obj的副本，并且这个副本会被传递给调用者。这个过程可能涉及到对象成员的逐个复制，对于包含大量数据成员或者动态分配内存的对象，这个复制过程可能会比较复杂和耗时。

返回值优化（RVO）和命名返回值优化(NRVO)

为了提高效率，现代编译器通常会进行返回值优化。RVO主要是在函数返回一个临时对象时发挥作用。例如，在MyClass getObject(){ return MyClass(); }这种情况下，编译器可以直接在调用者期望接受返回值的内存位置构造对象，而不是先在函数内部构造一个对象，然后再复制一份传递给调用者。

编译器可以直接在调用者期望接受返回值的内存位置构造对象，这段话的意思：

当函数返回一个临时对象时，例如MyClass getObject() { return MyClass(); }。
编译器会直接在调用者期望接收返回值的内存位置（比如调用函数中用来接收返回值的变量所在的内存位置）构造这个对象。也就是说，不会先在函数内部创建一个临时对象，再将其复制到调用者的变量中，而是跳过中间的复制步骤，直接在目标位置 "原地" 构造对象。
从内存角度看，假设调用函数中有MyClass result = getObject();，编译器会直接在result变量的内存空间构造MyClass对象，就好像函数内部的返回语句直接作用在result这个位置上一样。

NRVO是RVO的一种扩展，适用于函数返回一个有名字的局部对象的情况，比如前面提到的MyClass getObject(){ MyClass obj; return obj;}，编译器可以再适当的情况下，直接在调用者的内存位置构造obj的副本，避免了中间的复制过程。

3.指针和引用类型返回值的传递

指针返回值

当函数返回一个指针时，实际上返回的是一个内存地址。这个内存地址可以是栈上的（例如返回一个指向函数局部变量的指针，不过这种情况要小心，因为函数返回后局部变量就销毁了），也可以是堆上的（例如通过 new操作符分配内存后返回指针）。

例如，int* createArray() { int* arr = new int[5];return arr;}，这个函数返回一个指向堆上分配的int数组的指针。调用者可以通过这个指针来访问数组中的元素。不过，当调用者用完这个指针指向的内存后，需要通过delete[]来释放内存，以避免内存泄漏。

引用返回值

引用返回值就像是给一个已经存在的变量起了另外一个名字，函数返回引用时，实际上返回的是对象的别名。例如，int& getValue( int& ret){ return ref;}，这个函数返回传入引用参数的引用。调用者可以用过这个引用直接操作原始对象。引用返回值在一些情况下很有用，比如用于实现链式调用或者对对象进行原地修改等。不过和指针一样，返回引用是也要注意对象的生命周期，避免返回一个已经销毁的对象的引用

力扣 最长公共前缀-14