隨機算法和求最大數

1.實現RANDOMIZE-IN-PLACE隨機排列算法與PERMUTE-BYSORTING算法，並比較效率。

思路描述

將兩種取隨機數算法分別作爲兩個函數寫在i同一個程序裏面

調整：

• 我們一共需要一個多長的隨機序列：source code中用size進行描述🤗

• 我們將這個算法運行多少次 ，再source code中使用count_times 進行描述👀

手動調整參數，分析對比

分析結果

size = 10 ; count_times = 10000

size = 1000 , count_time = 100

size = 100 count = 1000

結論

就目前而言，無論在什麼情況下RANDOMIZE-IN-PLACE

算法都要較快一些

Source Code

// random.cpp : 此文件包含 "main" 函數。程序執行將在此處開始並結束。
//

#include "pch.h"
#include 
#include
#include
using namespace std;
void show_vector_int(vectoraim)
{
    for (int i = 0; i < aim.size(); i++)
        cout << aim[i]<<" ";
    cout << endl;
}

void get_random_rank_by_sorting(int size, vector& result,int bias)
{
    int n = size * size*size;
    srand((unsigned)time(0) + bias);
    for (int i = 0; i < size; i++)
    {

        result.push_back(rand() % n);
    }
    //show_vector_int(result);
    return;

}
void get_random_by_exchange(vector&result,int size,int bias)
{
    srand((unsigned)time(0)+bias);
    for (int i = 0; i < size; i++)
    {
        int aim = rand() % size;
        int tem = result[i];
        result[i] = result[aim];
        result[aim] = tem;
    }
    //show_vector_int(result);
    return;
}
int main()
{
    int size = 10;
    int count_times = 10000;
    cout << "one rank size is" << size << endl;
    cout << "run cycle is" << count_times << endl;
    clock_t start_time1, start_time2, end_time1, end_time2;
    start_time1 = clock();
    for (int i = 0; i < count_times; i++)
    {
        vectorresult;
        get_random_rank_by_sorting(size, result,i);
    }
    end_time1 = clock();
    cout << "the by_sorting time is about " << end_time1 - start_time1   << endl;
    vectorinitial;
    for (int i = 0; i < size; i++)
        initial.push_back(i);
    start_time2 = clock();
    for(int i = 0; i < count_times; i++)
    {
        vectorresult = initial;
        get_random_by_exchange(result, size,i);
    }
    end_time2 = clock();
    cout<< "the by_exchange_time is about " << end_time2 - start_time2 << endl;


    //std::cout << "Hello World!\n"; 
}

// 運行程序: Ctrl + F5 或調試 >“開始執行(不調試)”菜單
// 調試程序: F5 或調試 >“開始調試”菜單

// 入門提示: 
//   1. 使用解決方案資源管理器窗口添加/管理文件
//   2. 使用團隊資源管理器窗口連接到源代碼管理
//   3. 使用輸出窗口查看生成輸出和其他消息
//   4. 使用錯誤列表窗口查看錯誤
//   5. 轉到“項目”>“添加新項”以創建新的代碼文件，或轉到“項目”>“添加現有項”以將現有代碼文件添加到項目
//   6. 將來，若要再次打開此項目，請轉到“文件”>“打開”>“項目”並選擇 .sln 文件

.實現多數問題的Monte Carlo算法，並與其分治算法比較效率。Monte Carlo算法在實際中需要運行多少遍才能總是返回正確結果？

實現多數問題的Monte Carlo算法，並與其分治算法比較效率

思路

通過來兩個函數

• bool judge_major_cell_exit_with_Monte_Carlo(vector&aim,int bias)

• bool judge_major_cell_exit_with_qiurck_sort_like(vector&nums, int bias)

及其所依賴的子函數實現對於主元素的判斷

通過函數

• void get_the_vector_with_major_cell(vector&aim,int size,int bias)

生成一個帶有主元素的隨機數組

記錄其運行時間並比較

比較

通過調整兩個參數

• int run_cycle =10000;

• int vector_size = 10;

int run_cycle =10000; int vector_size = 10;

int run_cycle =10000; int vector_size = 100;

int run_cycle =10000; int vector_size = 1000;

Monte Carlo算法在實際中需要運行多少遍才能總是返回正確結果？

由上面可知

平均早1.2~1.3之內

#include 
#include
#include
#include
#include
using namespace std;
void show_random_vector(vector&aim)
{
    for (int i = 0; i < aim.size(); i++)
        cout << aim[i]<<" ";
    cout << endl;
}
void get_the_vector_with_major_cell(vector&aim,int size,int bias)
{
    srand((unsigned)time(0)+bias);
    for (int i = 0; i < size; i++)
        aim.push_back(0);
    int point = size / 2;
    int  other_size = rand()%point;
    for (int i = 0; i < other_size; i++)
    {
        int position = rand() % size;
        aim[position] = rand();
    }
    return;

}
bool judge_major_cell_exit_with_Monte_Carlo(vector&aim,int bias)
{
    srand((unsigned)time(0) + bias);
    int n = aim.size();
    int aim_cell_position = rand() % n;
    int times_count =0;
    for (int i = 0; i < n; i++)
    {
        if (aim[i] == aim[aim_cell_position])
            times_count++;
    }
    if (times_count > n / 2)
        return true;
    else
        return false;


}
int find_the_mid_cell(vector&nums, int left, int right, int bias)
{
//    cout << "we start from" << left << "we end at" << right << endl;
    srand((unsigned)time(0) + bias);
    int position = rand() % (right - left + 1) + left;
//    cout << "we choose the positon " << position << endl;
    int key = nums[position];
//    cout << "the key is" << key << endl;
    int i = left;
    int j = right;
    while (i != j)//進行中間替換
    {
//        cout << "i is" << i << endl;
///        cout << "j is" << j << endl;
        //show_vector(nums);
        while ((i != j && (nums[j] > key)))
        {
            j--;
        }
        int tem_int = nums[i];
        nums[i] = nums[j];
        nums[j] = tem_int;
        while ((i != j) && (nums[i] <= key))
        {
            i++;
        }
        tem_int = nums[i];
        nums[i] = nums[j];
        nums[j] = tem_int;
    }
    if (i == (nums.size() / 2))
        return nums[i];
    else if (i > (nums.size() / 2))
        return find_the_mid_cell(nums, left, i-1, bias++);
    else
        return find_the_mid_cell(nums, i+1, right, bias++);

}
bool judge_major_cell_exit_with_qiurck_sort_like(vector&nums, int bias)
{
    int size = nums.size();

    int maybe_major_cell = find_the_mid_cell(nums, 0, nums.size() - 1, bias);
    //cout<<"there"<= size / 2)
    {
        return true;
    }
    else
        return false;


}
int main()
{
    vector aim;
    int run_cycle =10000;
    int total_times = 0;
    int vector_size = 100;
    clock_t startime1, startime2, endtime1, endtime2;
    startime1 = clock();
    for (int i = 0; i < run_cycle; i++)
    {
        vector work;
        get_the_vector_with_major_cell(work,vector_size,i);
        int k = 0;
        while (judge_major_cell_exit_with_Monte_Carlo(work,i+k) == false )
        {
            total_times++;
            k++;
        }
        total_times++;

        //show_random_vector(work);
    }
    endtime1 = clock();
    cout<<"average cycle is "<< (total_times*1.0) / run_cycle<work;
        get_the_vector_with_major_cell(work, vector_size, i);
        //cout<<"wazzX"<