剑指offer自学系列(二)

题目描述:

在一个长度为n的数组里的所有数字都在0到n-1的范围内,数组中某些数字是重复的,但不知道有几个数字是重复的,也不知道每个数字重复几次,请找出数组中任一个重复的数字,例如,如果输入长度为7的数组{2,3,1,0,2,5,3},那么对应输出的第一个重复的数字为2

题目分析:

如果我们采用两个变量去找重复的值,需要嵌套两个循环,最坏的情况是,末尾的两个值是重复的,这显然不是我们想要的答案,如果采用排序的方式得到有序数组,然后从头到尾检索,很容易就能找到第一个重复的值,排序我们采用快速排序,排序时间复杂度为o(nlogn),检索重复的值时间复杂度为o(n),我们也可以采用空间换时间,实现一个hash表,时间复杂度为o(n),检索数组,将值存到hash表中,如果hash表里没有出现这个值,就存到hash表中,如果出现过这个值,那就是我们想要的重复的值,每次查找需要o(1)的时间复杂度。

由于所有数字都在0到n-1的范围内,和数组下标恰好相对应,我们可以用交换的方法快速找到重复的值,以{2,3,1,0,2,5,3}为例:

首先第一个值为2,与下标为2的1交换,{1,3,2,0,2,5,3}

第二步交换后的值为1,继续与下标为1的值交换,{3,1,2,0,2,5,3}

第三步交换后的值为3,与下标为3的值交换,{0,1,2,3,2,5,3}

第四步,前四个值都有序,第五个值为2,与下标为2的值交换,而第二个值已经是2,结束

代码如下:

#include<iostream>
using namespace std;

bool duplicate(int numbers[],int length,int* duplication) {
    if (numbers == nullptr || length <= 0) {
        return false;
    }
    for (int i = 0; i < length;++i) {
        if (numbers[i]<0 || numbers[i]>length - 1)
            return false;
    }
    for (int i = 0; i < length;++i) {
        while (numbers[i] != i) {
            if (numbers[i] == numbers[numbers[i]]) {
                *duplication = numbers[i];
                return true;
            }
            int temp = numbers[i];
            numbers[i] = numbers[temp];
            numbers[temp] = temp;
        }
    }
}

int main() {
    int A[7] = {2,3,1,0,2,5,3};
    int len = 7;
    int i = 0;
    int duplication;
    bool results = duplicate(A, 7,&duplication);
    cout << results << endl;
    cout << duplication << endl;
}

在写的过程中,我碰到了几个问题,算是C++基础问题,在此总结一下,我思索函数为什么要引用&duplication,直接用duplication不行嘛,尝试了一下报错,提示我这是局部变量,值传不回来的,所以通过对地址修改才能得到这个值,还有一点,我原以为会传两个值,2和3,但是return true返回后函数体部分就结束了,所以只会返回一个值,在此做笔记是为了加强自己记忆,不要再犯基础知识上的错误。

题目描述:

给定一个数组A[0,1,…,n-1],请你构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]xA[1]x…xA[i-1]xA[i+1]x…xA[n-1],要求不能使用除法

题目分析:

对于这个题目,由于要求我们不能采用除法,所以只能采用巧妙的方法计算这些数的乘积,我们首先表示B数组

B[0] = A[1]xA[2]x…xA[i-1]xA[i]x…xA[n-2]xA[n-1]

B[1] = A[0]xA[2]x…xA[i-1]xA[i]x…xA[n-2]xA[n-1]

B[i-1] = A[0]xA[1]x…xA[i-2]xA[i]x…xA[n-2]xA[n-1]

B[i] = A[0]xA[1]x…xA[i-1]xA[i+1]x…xA[n-2]xA[n-1]

B[n-2] = A[0]xA[1]…xA[i-1]xA[i]x…xA[n-3]xA[n-1]

B[n-1] = A[0]xA[1]…xA[i-1]xA[i]x…xA[n-3]xA[n-2]

为了让它们数组显得更有规律,写成矩阵如下

这里写图片描述

我们把被除的那些值用1代替即可以化除法为乘法,符合题目要求,下面是找到一种减少时间复杂度的方法,我们将表分成两部分,以1的斜对角线为分界线,上面从上到下相乘,下面从下往上乘,最后乘到一起即得到需要的值,代码如下:

#include<iostream>
#include<vector>
using namespace std;

void multipy(const vector<double> A,vector<double> B) {
    int lenA = A.size();
    int lenB = B.size();
    if (lenA == lenB && lenB > 1) {
        B[0] = 1;
        for (int i = 1; i < lenA; ++i) {
            B[i] = A[i - 1] * B[i - 1];
        }
        double temp = 1;
        for (int i = lenA - 2; i >= 0; --i) {
            temp = temp * A[i + 1];
            B[i] = B[i] * temp;
        }
        for (int i = 0; i < lenA; ++i) {
            cout << B[i] << endl;
        }
    }
}

int main() {
    vector<double> A = {1,2,1,2,1,2,1};
    vector<double> B = {1,1,1,1,1,1,1};
    multipy(A, B);
    return 0;
}

 

参考:

https://blog.csdn.net/qq_33278461/article/details/80144734(矩阵图片)

posted @ 2019-03-26 20:40  薛定谔的哈士奇  阅读(121)  评论(0编辑  收藏  举报