Алгоритм для многопоточности

#include <QCoreApplication>
#include "Worker.h"
#include <iostream>
#include <QThread>
#include <QTime>
 
typedef unsigned long long size_t;
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    QThread thread;
    Worker oneThread;
 
    QTime time = QTime::currentTime();
    size_t size = 1000;
    int* array = new int[size];
    for (int index = 0; index < size; ++index)
    {
        array[index] = rand() % size + 1;
    }
    std::cout << "Max: " << oneThread.getMax(array, 0, size) << std::endl;// я правильно  тут делаю?
    int msec = time.msecsTo( QTime::currentTime() );
    std::cout << "Run time: " << msec << std::endl;
    QObject::connect(&thread,SIGNAL(started()),&oneThread,SLOT(getMax(int array[], int firstIndex, int lastIndex));// и тут
 
    QObject::connect(&oneThread,SIGNAL(finished()),&thread,SLOT(terminate()));
    oneThread.moveToThread(&thread);
 
    oneThread.run();// у меня  же  run() нету,  что  тут  вместо єтой функции?
    return app.exec();
}

#ifndef FIND_MAX_IN_ARRAY_THREAD_H
#define FIND_MAX_IN_ARRAY_THREAD_H
 
#include <QThread>
 
class FindMaxInArrayThread : public QThread
{
    Q_OBJECT
public:
    FindMaxInArrayThread(const int array[], size_t startIndex, size_t numElements, int* result);
    virtual void run();
 
private:
    const int* mArray;
    size_t mStartIndex;
    size_t mNumElements;
    int* mResult;
};
 
#endif // FIND_MAX_IN_ARRAY_THREAD_H

#include "FindMaxInArrayThread.h"
#include <algorithm>
 
FindMaxInArrayThread::FindMaxInArrayThread(const int array[], size_t startIndex, size_t numElements, int* result)
    : mArray(array)
    , mStartIndex(startIndex)
    , mNumElements(numElements)
    , mResult(result)
{
}
 
void FindMaxInArrayThread::run()
{
    const int* it = mArray + mStartIndex;
    const int* itEnd = it + mNumElements;
    const int* maxIt = std::max_element(it, itEnd);
    *mResult = *maxIt;
}

#include <QCoreApplication>
#include <QTime>
#include <QDebug>
#include "FindMaxInArrayThread.h"
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    QTime time(QTime::currentTime());
    std::srand(time.msecsSinceStartOfDay());
 
    const size_t numElements = 10000000;
    int* elements = new int[numElements];
    for (size_t index = 0; index < numElements; ++index)
        elements[index] = std::rand() % numElements;
 
    int result = 0;
    FindMaxInArrayThread maxInArrayThread(elements, 0, numElements, &result);
 
    time.start();
    maxInArrayThread.start();
    maxInArrayThread.wait();
    int elapsedMs = time.elapsed();
 
    qDebug() << "Elapsed time(ms): " << elapsedMs;
    qDebug() << "Result: " << result;
    delete[] elements;
 
    return app.exec();
}

#include <QCoreApplication>
#include <QTime>
#include <QDebug>
#include "FindMaxInArrayThread.h"
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    QTime time(QTime::currentTime());
    std::srand(time.msecsSinceStartOfDay());
 
    const size_t numElements = 10000000;
    int* elements = new int[numElements];
    for (size_t index = 0; index < numElements; ++index)
        elements[index] = std::rand() % numElements;
 
    //здесь получить с консоли число потоков N
    //разделить массив на N кусков 
    int result = 0; //вместо этого заведи масив на N элементов сюда будешь писать result
    FindMaxInArrayThread maxInArrayThread(elements, 0, numElements, &result); //создать N таких объектов
    //передавай сюда массив и границы поиска (отрезок массива), и куда писать результат
 
    time.start();
    maxInArrayThread.start();   //стартуешь каждый из N потоков
    maxInArrayThread.wait();    //ждешь каждый из N потоков
    
    //сюда добавь метод который найдет в массиве результатов максимальное.
    
    int elapsedMs = time.elapsed();
 
    qDebug() << "Elapsed time(ms): " << elapsedMs;
    qDebug() << "Result: " << result;
    delete[] elements;
 
    return app.exec();
}

 int* result = new  int[2];

#include <QCoreApplication>
#include <QTime>
#include <QDebug>
#include "FindMaxInArrayThread.h"
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    QTime time(QTime::currentTime());
    std::srand(time.msecsSinceStartOfDay());
 
    const size_t numElements = 10000000;
    int* elements = new int[numElements];
    for (size_t index = 0; index < numElements; ++index)
        elements[index] = std::rand() % numElements;
 
    int numberThread = 2;
    int* result = new  int[numberThread];
    const size_t divElements = numElements / numberThread;
    
    FindMaxInArrayThread maxInArrayThread1(elements, 0, divElements, &result);
    FindMaxInArrayThread maxInArrayThread2(elements, divElements, numElements, &result);
 
    time.start();
    for (size_t index = 0; index < numElements; ++index)
    {
        maxInArrayThread1.start();
        maxInArrayThread2.start();
        
    }
    
    for (size_t index = 0; index < numElements; ++index)
    {
        maxInArrayThread1.wait();
        maxInArrayThread2.wait();
        
    }
    if (maxInArrayThread1 > maxInArrayThread2)
        result = maxInArrayThread1;
    else
        result = maxInArrayThread2;
    
    int elapsedMs = time.elapsed();
 
    qDebug() << "Elapsed time(ms): " << elapsedMs;
    qDebug() << "Result: " << result;
    delete[] elements;
 
    return app.exec();
}

#include <QCoreApplication>
#include <QTime>
#include <QDebug>
#include "FindMaxInArrayThread.h"
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    QTime time(QTime::currentTime());
    std::srand(time.msecsSinceStartOfDay());
 
    const size_t numElements = 100000001;
    int* elements = new int[numElements];
    for (size_t index = 0; index < numElements; ++index)
        elements[index] = std::rand() % numElements;
 
    const int numberThreads = 2;
    int* results = new int[numberThreads];
    size_t divElements  = 0;
    int oElements = numElements % numberThreads;
    if (oElements == 0) 
        divElements = numElements / numberThreads;
 
    FindMaxInArrayThread maxInArrayThread1(elements, 0, divElements, results);
    FindMaxInArrayThread maxInArrayThread2(elements, divElements, divElements + oElements , results + 1);
 
    time.start();
 
    maxInArrayThread1.start();
    maxInArrayThread2.start();
 
    maxInArrayThread1.wait();
    maxInArrayThread2.wait();
 
    int elapsedMs = time.elapsed();
 
    qDebug() << "Elapsed time(ms): " << elapsedMs;
    qDebug() << "Result: " << std::max(results[0], results[1]);
    delete[] elements;
    delete[] results;
 
    return app.exec();
}

int oElements = numElements % numberThreads;
    if (oElements == 0) 
        divElements = numElements / numberThreads;
 
    FindMaxInArrayThread maxInArrayThread1(elements, 0, divElements, results);
    FindMaxInArrayThread maxInArrayThread2(elements, divElements, divElements + oElements , results + 1);