頭歌 | 數據結構與算法課程設計-算法與競賽(第3章) - C++與算法基礎二

Algorithm 中文意思是算法，是一個計算的具體步驟，常用於數據處理、計算以及自動推理。它作為 C++ 標准模版庫 STL 中最重要的頭文件之一，其提供了大量非成員模版函數，例如排序操作、二分查找操作、集合操作以及堆操作等。同時可以通過迭代器或指針訪問任何對象序列，例如 STL 容器數組或實例。更多的了解請參考官方文檔 。

本實訓主要設置了四個關卡：第一關和第二關介紹了 Algorithm 中的二分搜索操作 binary_search 及其相關搜索操作；第三關是修改序列操作 Modifying sequence operations ；第四關講的是非修改序列操作 Non-modifying sequence operations 。最后在每個關卡都設置了實例，考察學員對所講內容的理解和在線編程能力。

 

第1關：二分查找：在N個無序整數里面查找M個指定整數

 任務描述

本關任務：給定包含 N 個整數的無序序列 S(a1​,a2​,..,aN​)，以及 M 次查詢序列 Q(b1​,b2​,..,bM​)，判定 bj​ 是否在序列 S 中。

相關知識

為了完成本關任務，你需要掌握：1.解題思路，2.快速排序算法，3.二分查找算法。

解題思路

本關卡問題清晰，解法簡單：對於每次查詢bj​，在序列S中遍歷ai​是否等於bj​。雖然該解法實現簡單，但是執行效率低，運算復雜度高O(N×M)。

高效解法：首先運用快速排序算法，將無序序列變為有序（升序），然后對每次查找操作，使用二分查找算法判斷元素是否存在。該解法實現稍微有點復雜，但是執行效率高，運算復雜度低O(N×logN+M×logN)。

快速排序算法

快速排序算法的背景和原理前面已有很多實訓介紹過了，為了方便實現，一般使用 algorithm 中模板函數 sort ，請認真參考實訓《算法與競賽(第2章) - C++與Algorithm基礎一》 的第三個關卡，之后的實訓將不再對sort進行講解。

二分查找算法

二分查找算法也稱折半查找算法 Binary Search Algorithm ，它是一種效率較高的查找方法，復雜度為O(logN​)。二分查找算法要求線性表（序列）必須采用順序存儲結構，而且表中元素按關鍵字有序排列。

核心思想：將表中間位置記錄的關鍵字與待查找的關鍵字進行比較，如果兩者相等，則查找成功；否則利用中間位置記錄將表分成前、后兩個子表，如果中間位置記錄的關鍵字大於查找關鍵字，則進一步查找前一子表，否則進一步查找后一子表。重復以上過程，直到找到滿足條件的記錄，使查找成功，或直到子表不存在為止，此時查找不成功。

幸運的是，C++ 在 Algorithm 算法模板中集成了二分查找算法，這樣僅僅調用一個模板函數 binary_search 就可以實現指定元素（關鍵字）的查找了。其函數原型及其應用實例如下：

\\ binary_search函數原型
default (1):
    template <class ForwardIterator, class T>
    bool binary_search (ForwardIterator first, ForwardIterator last, const T& val);
custom (2):
    template <class ForwardIterator, class T, class Compare>
    bool binary_search (ForwardIterator first, ForwardIterator last, const T& val, Compare comp);
\\ binary_search應用實例
int arr[4] = {1,2,3,4}; // 升序數組
bool judge1 = binary_search(arr, arr+4, 1); // judge1結果為true
bool judge2 = binary_search(arr, arr+4, 5); // judge2結果為false

本關卡使用的是整型數據，使用默認的模板函數即可。若有興趣學習自定義數據類型下的二分查找，請參考實訓《算法與競賽(第2章) - C++與Algorithm基礎一》第三個關卡對自定義數據類型的相關操作。

編程要求

本關的編程任務是補全右側代碼片段 main 中 Begin 至 End 中間的代碼，具體要求如下：

在 main 中，讀取N個無序序列，並存儲在數組中，然后對無序數組進行排序，最后調用二分查找算法完成 M 次指定元素的查找任務，並輸出查找結果。若在序列中，輸出 bj​ in array，否則輸出 bj​ not in array。

測試說明

平台將自動編譯補全后的代碼，並生成若干組測試數據，接着根據程序的輸出判斷程序是否正確。

以下是平台的測試樣例：

測試輸入：

7

2 5 9 5 5 3 1

3

4 7 5

預期輸出：

4 not in array

7 not in array

5 in array

 

輸入格式：

第一行：序列元素個數N

第二行：N個無序序列元素

第三行：查詢次數M

第四行：M個待查詢元素

輸出格式：

輸出M行，每行對應查詢結果，每行末尾換行！！！

---

開始你的任務吧，祝你成功！

 

 

//
//  main.cpp
//  step1
//
//  Created by ljpc on 2018/7/8.
//  Copyright ? 2018年 ljpc. All rights reserved.
//

#include <iostream>
#include <algorithm>
#include <cstdio>

using namespace std;

int main(int argc, const char * argv[]) 
{

    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    int n,m;
    cin>>n;
    int a[n+10];//需要注意的是，有的編譯器支持這種定義方法，有的不支持
    //可以考慮直接定義一個很大的數組 
    //如果這樣定義的話，順序不能顛倒，只有有了n之后才可以定義這個數組 
    
    for(int i=1;i<=n;i++) cin>>a[i];//依次輸入這n個無序序列並儲存在數組中 
    
    sort(a,a+n+1);//利用sort函數對無序數組進行排序，sort默認使用 < 號 
    
    cin>>m;
    int b[m+10];
    for(int i=1;i<=m;i++)
        cin>>b[i];
        
    for(int i=1;i<=m;i++){//利用for循環依次對數組中存儲的每一個數在有序數組a中進行查找 
        if(binary_search(a,a+n,b[i])) //binary_search函數題目中有寫到，是對有序數組進行查找的 
            cout<<b[i]<<" in array"<<endl;
        else cout<<b[i]<<" not in array"<<endl;
    }
    /********** End **********/    
    
    return 0;
}

 

 

 

第2關二分查找：在N個有序整數里面查找M個指定整數的閉區間位置

任務描述

本關任務：給定包含N個整數的升序序列S(a1​,a2​,..,aN​)，以及M次查詢序列Q(b1​,b2​,..,bM​)，求bj​在序列S中的閉區間位置（測試數據保證bj​存在序列S中），例如2在升序序列 1，2，2，3 中的閉區間位置為 [1,2] 。

相關知識

為了完成本關任務，你需要掌握：1.模板函數 lower_bound ，2.模板函數 upper_bound ，3.模板函數 equal_range 。

模板函數 lower_bound

上個關卡介紹了 binary_search 的模板函數，實際上它的內部實現是基於 lower_bound 函數實現的，通過 lower_bound 在有序序列里查找不小於關鍵字的元素，並返回元素索引位置最低的地址，最后根據地址來判斷是否查找成功，代碼如下：

template <class ForwardIterator, class T>
bool binary_search (ForwardIterator first, ForwardIterator last, const T& val){
     first = std::lower_bound(first,last,val);
     return (first!=last && !(val<*first));
    //first!=last為true：說明找到一個不小於關鍵字的元素
    //!(val<*first) 為true：說明該元素與待查找關鍵字相等
}

模板函數 lower_bound 的基本用途是查找有序區間中第一個 大於或等於 某給定值的元素的位置，由此本關卡的任務可以利用 lower_bound 獲取序列中等於待查找關鍵字的元素的位置。其函數原型及其應用實例如下：

\\ 函數原型
default (1):
    template <class ForwardIterator, class T>
    ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T& val);
custom (2):
    template <class ForwardIterator, class T, class Compare>
    ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,const T& val, Compare comp);
\\ 應用實例
int arr[5] = {1,2,2,4,5};
int a = lower_bound(arr, arr+5, 2) - arr; // a結果為1

模板函數 upper_bound

模板函數 upper_bound 的基本用途與 lower_bound 相對，是查找有序區間中第一個 大於 某給定值的元素的位置，由此本關卡的任務可以利用 upper_bound 獲取序列中第一個 大於 待查找關鍵字的元素的位置，往前移一位就是最后一個等於待查找關鍵字的元素的位置。其函數原型及其應用實例如下：

\\ 函數原型
default (1):
    template <class ForwardIterator, class T>
    ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T& val);
custom (2):
    template <class ForwardIterator, class T, class Compare>
    ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T& val, Compare comp);
\\ 應用實例
int arr[5] = {1,2,2,4,5};
int b = upper_bound(arr, arr+5, 2) - arr; // b結果為3

模板函數 equal_range

模板函數 equal_range 綜合了 lower_bound 和 upper_bound 的功能，通過內部調用這兩個上下界查找函數，返回兩個地址並組成 pair ：第一個地址是序列中第一個大於等於待查找關鍵字的元素位置，而第二個地址是第一個大於待查找關鍵字的元素位置。因為本關卡的數據保證在序列中存在待查找關鍵字，所以 equal_range 返回的是一個左閉右開的區間位置。其函數原型及其應用實例如下：

default (1):
    template <class ForwardIterator, class T>
    pair<ForwardIterator,ForwardIterator>
    equal_range (ForwardIterator first, ForwardIterator last, const T& val);
custom (2):
    template <class ForwardIterator, class T, class Compare>
    pair<ForwardIterator,ForwardIterator>
    equal_range (ForwardIterator first, ForwardIterator last, const T& val, Compare comp);

模板函數 equal_range 基於 lower_bound 和 upper_bound 的函數內部實現如下：

\\ 函數原型
template <class ForwardIterator, class T>
pair<ForwardIterator,ForwardIterator>
equal_range (ForwardIterator first, ForwardIterator last, const T& val){
    ForwardIterator it = std::lower_bound (first,last,val);
    return std::make_pair ( it, std::upper_bound(it,last,val) );
}
\\ 應用實例
int arr[5] = {1,2,2,4,5};
auto bounds = equal_range(arr, arr+5, 2);
int a = bounds.first-arr; // a結果為1
int b = bounds.second-arr; // b結果為3

編程要求

本關的編程任務是補全右側代碼片段 main 中 Begin 至 End 中間的代碼，具體要求如下：

在 main 中，讀取 N 個升序序列，並存儲在數組中，基於 lower_bound 和 upper_bound 算法（或 equal_range ）完成M次指定元素的查找任務，並輸出查找閉區間結果（輸出格式嚴格遵循樣例）。

測試說明

平台將自動編譯補全后的代碼，並生成若干組測試數據，接着根據程序的輸出判斷程序是否正確。

以下是平台的測試樣例：

測試輸入：

7

1 1 2 3 5 5 6

2

5 6

預期輸出：

5 at order array position [4,5]

6 at order array position [6,6]

 

輸入格式：

第一行：序列元素個數N

第二行：N個升序序列元素

第三行：查詢次數M

第四行：M個待查詢元素

輸出格式：

輸出M行，每行對應查詢結果，每行末尾換行！！！

---

開始你的任務吧，祝你成功！

//
//  main.cpp
//  step2
//
//  Created by ljpc on 2018/7/8.
//  Copyright ? 2018年 ljpc. All rights reserved.
//

#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;

int main(int argc, const char * argv[]) 
{
   
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    int n;
    cin>>n;//獲取有序序列的元素個數，便於利用循環輸入序列 
    int a[n+10];//定義一個數組用於存儲序列 
    for(int i=0;i<=n-1;i++){//利用for循環不斷輸入序列 
        //要注意一下這里，需要從數組的第一個位置開始記錄
        cin>>a[i]; 
    } 
    
    int m;
    cin>>m;//獲取要在有序序列中的查詢次數 
    int b[m+10];//定義數組b用於存儲待查找元素 
    for(int i=0;i<=m-1;i++){
        //要注意一下這里，需要從數組的第一個位置開始記錄 
        cin>>b[i];
        
    } 
    for(int i=0;i<=m-1;i++){
        auto bounds = equal_range(a,a+n,b[i]);
        //利用函數equal_range查詢 
        int j=bounds.first-a;//序列中第一個【大於等於】待查找關鍵字的元素位置 
        int p=bounds.second-a;//序列中第一個【大於】待查找關鍵字的元素位置 
        cout<<b[i]<<" at order array position ["<<j<<","<<p-1<<"]"<<endl;
        //因為p是大於的位置，而我們要求的是閉區間，所以應該減去 1 
    } 

 

如果因為個人習慣問題，喜歡將for循環中的i從1開始記錄的話，代碼應該這么寫：

#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;

int main(int argc, const char * argv[]) 
{
   
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    int n;
    cin>>n;//獲取有序序列的元素個數，便於利用循環輸入序列 
    int a[n+10];//定義一個數組用於存儲序列 
    for(int i=1;i<=n;i++){//利用for循環不斷輸入序列 
        cin>>a[i]; 
    } 
    
    int m;
    cin>>m;//獲取要在有序序列中的查詢次數 
    int b[m+10];//定義數組b用於存儲待查找元素 
    for(int i=1;i<=m;i++){
        //要注意一下這里，需要從數組的第一個位置開始記錄 
        cin>>b[i];
        
    } 
    for(int i=1;i<=m1;i++){
        auto bounds = equal_range(a+1,a+n+1,b[i]);
        //利用函數equal_range查詢 
        int j=bounds.first-a;//序列中第一個【大於等於】待查找關鍵字的元素位置 
        int p=bounds.second-a;//序列中第一個【大於】待查找關鍵字的元素位置 
        cout<<b[i]<<" at order array position ["<<j<<","<<p-1<<"]"<<endl;
        //此時，j和 p所代表的地址實際上比要查找的關鍵字的地址還要大於 1，所以應該都減 1 
        //又因為p是大於的位置，而我們要求的是閉區間，所以應該減去 2 
    } 


    /********** End **********/
 
    return 0;
}

 

 

第3關修改序列（數組）操作的應用

任務描述

本關任務：編寫一個程序，實現復制Copy_N，交換Swap，取代Replace，填充Fill，倒置Reverse，滾動Rotate等修改序列操作。

相關知識

為了完成本關任務，你需要掌握：1.復制Copy_N，2.交換Swap，3.取代Replace，4.填充Fill，5.倒置Reverse，6.滾動Rotate。

復制Copy_N

Algorithm中有兩個常用的復制函數：copy和copy_n，其中copy復制整個數組到新的數組中，而copy_n則是可選擇的復制前n個元素到新的數組。 copy函數原型及其應用實例如下，參數first為數組首地址，參數last為數組尾地址，參數result為新數組首地址：

\\ 函數原型
template <class InputIterator, class OutputIterator>
OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result);
\\ 應用實例
int arr1[4] = {1,3,2,4};
int arr2[4];
copy(arr1, arr1+4, arr2);
\\或者 arr2 =  copy(arr1, arr1+4, arr2);

copy_n函數原型及其應用實例如下，參數first為數組首地址，參數n為要復制的數組元素個數，參數result為新數組首地址：

\\ 函數原型
template <class InputIterator, class Size, class OutputIterator>
OutputIterator copy_n (InputIterator first, Size n, OutputIterator result);
\\ 應用實例
int arr1[4] = {1,3,2,4};
int arr2[4];
copy_n(arr1, 4, arr2);

交換Swap

Algorithm中交換模板函數為swap，傳入兩個參數地址引用，功能是交換這兩個參數的數值，其函數原型及其應用實例如下：

\\ 函數原型
template <class T> void swap (T& a, T& b)
\\ 應用實例
int a=1, b=2;
swap(a, b);
\\ a結果為2，b結果為1

取代Replace

Algorithm中取代模板函數為replace，傳入參數first為數組首地址，參數last為數組尾地址，要被替換的舊元素為參數old_value，替換的新的元素為參數new_value，函數功能是將數組中所有的old_value替換為new_value，其函數原型及其應用實例如下：

\\ 函數原型
template <class ForwardIterator, class T>
void replace (ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
\\ 應用實例
int arr[4] = {1,2,2,3};
replace(arr, arr+4, 2, 0);
\\ arr結果為{1,0,0,3}

填充Fill

Algorithm中填充模板函數為fill，傳入參數first為數組首地址，參數last為數組尾地址，填充值為參數val，函數功能是將數組中的所有元素都重新賦值為val，其函數原型及其應用實例如下：

\\ 函數原型
template <class ForwardIterator, class T>
void fill (ForwardIterator first, ForwardIterator last, const T& val);
\\ 應用實例
int arr[4] = {1,2,2,3};
fill(arr, arr+4, 5);
\\ arr結果為{5,5,5,5}

特別的，類似的填充函數還有memset，在頭文件string.h中，但是賦值有限，一般僅限於-1，0，若設置為其他數值，則實際結果有誤。

倒置Reverse

Algorithm中倒置模板函數為reverse，傳入參數first為數組首地址，參數last為數組尾地址，函數功能是將數組中的所有元素對稱交換，例如比如1 2 3，變為3 2 1，其函數原型及其應用實例如下：

\\ 函數原型
template <class BidirectionalIterator>
void reverse (BidirectionalIterator first, BidirectionalIterator last);
\\ 應用實例
int arr[4] = {1,2,3,4};
reverse(arr, arr+4);
\\ arr結果為{4,3,2,1}

滾動Rotate

Algorithm中滾動模板函數為rotate，傳入參數first為數組首地址，參數last為數組尾地址，而參數middle則是數組中要滾動的最后一個元素的后一個地址，滾動完成后該地址將成為首地址，比如數組arr=[0,1,2,3,4]，相應的參數為first=arr，last=arr+5，middle=arr+3，則滾動后的結果為3 4 0 1 2，其函數原型及其應用實例如下：

\\ 函數原型
template <class ForwardIterator>
ForwardIterator rotate (ForwardIterator first, ForwardIterator middle, ForwardIterator last);
\\ 應用實例
int arr[5] = {0,1,2,3,4};
rotate(arr, arr+3, arr+5);
\\ arr結果為{3,4,0,1,2}

編程要求

本關的編程任務是補全右側代碼片段Copy_N，Swap，Reverse，Replace，Fill，和Rotate中Begin至End中間的代碼，具體要求如下：

• 在Copy_N中，復制數組arr中前n個元素到一個新的數組，並將新數組作為函數返回值。
• 在Swap中，實現整數x和整數y數值交換，因為傳入的參數為地址引用，所以對x和y的修改都是真實有效的修改，也就是說會改變原來的值。
• 在Reverse中，實現數組arr所有元素首尾倒置，即交換arr[0]與arr[n-1]，arr[1]與arr[n-2]，以此類推。
• 在Replace中，將數組arr中所有的元素x都替換為新的元素y。
• 在Fill中，實現數組arr的填充，將所有的元素賦值為元素z。
• 在Rotate中，實現m次數組arr左向滾動，即每次數組滾動將arr[0]移動到數組末尾，然后元素依次往前移動一位。

以上所有功能學員可以基於Algorithm模板庫調用相應的模板函數來實現，也可以自己編寫具體代碼來實現，進一步理解其原理和作用。

測試說明

平台將自動編譯補全后的代碼，並隨機生成若干組測試數據，接着根據程序的輸出判斷程序是否正確（學員不需要關注測試用例，只需實現上述的編程要求即可）。

---

開始你的任務吧，祝你成功！

 

//
//  code.cpp
//  step3
//
//  Created by ljpc on 2018/7/12.
//  Copyright ? 2018年 ljpc. All rights reserved.
//

#include "code.h"

int* Copy_N(int *arr, int n)
// 函數功能：復制數組arr中前n個元素並作為函數返回值
{
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    int *arr2 = new int[n];
    for(int  i=0;i<n;i++){
        arr2[i]=arr[i];
    }
    return arr2;
    /********** End **********/
}

void Swap(int &a, int &b)
// 函數功能：交換參數x和參數y
{
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    swap(a,b);

    /********** End **********/
}

void Replace(int *arr, int n, int x, int y)
// 函數功能：在數組arr中將元素x替換為y，其中n為數組個數
{
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    replace(arr,arr+n,x,y);

    /********** End **********/
}

void Fill(int *arr, int n, int z)
// 函數功能：將大小為n的數組的所有元素填充為元素z
{
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    fill(arr,arr+n,z);

    /********** End **********/
}

void Reverse(int *arr, int n)
// 函數功能：倒置數組arr的元素，比如1 2 3，變為3 2 1，其中n為數組個數
{
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    reverse(arr,arr+n);

    /********** End **********/
}

void Rotate(int *arr, int n, int m)
// 函數功能：向左邊滾動m個元素，並補到數組右邊，比如 1 2 3 4，滾動m=2個元素，結果為3 4 1 2，其中n=4是數組個數
{
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    rotate(arr,arr+m,arr+n);

    /********** End **********/
}

 

 

 

第4關：非修改序列（數組）操作的應用

任務描述

本關任務：編寫一個程序，實現無序數組查找指定元素Find，無序數組查找指定數組子序列Find_End，指定元素個數統計Count，兩個數組相等比較Equal等非修改序列操作。

相關知識

為了完成本關任務，你需要掌握：1.無序數組查找指定元素Find，2.無序數組查找指定數組子序列Find_End，3.指定元素個數統計Count，4.兩個數組相等比較Equal。

無序數組查找指定元素Find

與上個實訓介紹的二分查找binary_search不一樣，Algorithm中的模板函數find可以在無序數組中的查找指定元素x，若存在則返回第一個x所在的地址，否則返回數組尾地址，其函數原型及其應用實例如下，其中傳入參數first為數組首地址，參數last為數組尾地址，待查找指定元素為參數val：

\\ 函數原型
template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val);
\\ 應用實例
int arr[4] = {1,3,2,3};
int *p = find(arr, arr+4, 3); // p結果為地址arr+1
int *q = find(arr, arr+4, 0); // q結果為地址arr+4

無序數組查找指定數組子序列Find_End

Algorithm中的模板函數find_end可以在無序數組arr1中的查找指定子數組arr2是否存在，若存在則返回待查子數組arr2最后出現在原數組arr1的地址，否則返回原數組的尾地址，例如arr1=[0,3,4,3,4]，arr2=[3,4]，返回結果為arr1+3，其函數原型及其應用實例如下：

\\ 函數原型
template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);
\\ 應用實例
int arr[5] = {0,3,4,3,4};
int arr1[2] = {3,4};
int arr2[2] = {3,5};
int *p = find_end(arr, arr+5, arr1, arr1+2); // p結果為地址arr+3
int *q = find_end(arr, arr+5, arr2, arr2+2); // q結果為地址arr+5

特別的，如想要第一次出現的地址，模板函數search 可以實現這一功能，使用方式同上，其函數原型如下：

template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);

指定元素個數統計Count

Algorithm中的模板函數count可以在數組中統計指定元素x出現的次數，傳入參數first為數組首地址，參數last為數組尾地址，參數x為待統計的指定元素，其函數原型及其應用實例如下：

\\ 函數原型
template <class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type count (InputIterator first, InputIterator last, const T& val);
\\ 應用實例
int arr[5] = {0,3,4,3,4};
int cnt = count(arr, arr+5,3); // cnt結果為2

兩個數組相等比較Equal

兩個數組相等意思是數組個數相同，對應位置上的元素值也相同，Algorithm中的模板函數equal就可以比較兩個數組是否相等，返回比較真值，其函數原型及其應用實例如下，其中參數first1是第一個數組的首地址，參數last1是第一個數組的尾地址，參數first2是第二個參數的首地址，默認兩個數組元素個數是相同的，否則沒有比較意義：

\\ 函數原型
template <class InputIterator1, class InputIterator2>
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
\\ 應用實例
int arr1[2] = {3,4};
int arr2[2] = {3,4};
int arr3[2] = {3,5};
bool judge1 = equal(arr1, arr1+2, arr2); // judge1結果為地址true
bool judge2 = equal(arr1, arr1+2, arr3); // judge2結果為地址false

編程要求

本關的編程任務是補全右側代碼片段Find，Find_End，Count和Equal中Begin至End中間的代碼，具體要求如下：

• 在Find中，對於給定的數組首地址和尾地址，查找元素x是否在數組中，若在則返回第一個x所在的地址，否則返回數組尾地址。
• 在Find_End中，對於給定數組arr1及其個數n1，數組arr2及其個數n2，查找數組arr2是否在arr1中，若數組arr2在數組arr1中出現，則返回數組arr2[0]在arr1中最后一次出現的地址，否則，返回數組arr1尾地址，即arr1+n1。
• 在Count中，統計指定元素x在數組中出現的次數。
• 在Equal中，對於給定數組arr1及其個數n1，數組arr2，比較兩個數組是否相等，若相等則返回true，否則返回false。

以上所有功能學員可以基於Algorithm模板庫調用相應的模板函數來實現，也可以自己編寫具體代碼來實現，進一步理解其原理和作用。

測試說明

平台將自動編譯補全后的代碼，並隨機生成若干組測試數據，接着根據程序的輸出判斷程序是否正確（學員不需要關注測試用例，只需實現上述的編程要求即可）。

---

開始你的任務吧，祝你成功！

 

//
//  code.cpp
//  step4
//
//  Created by ljpc on 2018/7/14.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "code.h"

int* Find(int *first, int *last, int x)
// 函數功能：給定數組首地址和尾地址，若x在數組中，返回第一個x所在的地址，否則返回尾地址
{
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    //int static *q = find(*first,*last,x);
    return find(first,last,x);
    /********** End **********/
}

int* Find_End(int *arr1, int n1, int *arr2, int n2)
// 函數功能：給定數組arr1，個數n1，數組arr2，個數n2，
//         若數組arr2在數組arr1中出現（連續），則返回數組arr2[0]在arr1中最后一次出現的地址
//         否則，返回數組arr1尾地址，即arr1+n1
{
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    int *q=find_end(arr1,arr1+n1,arr2,arr2+n2);
    return q;
    /********** End **********/
}

int Count(int *first, int *last, int x)
// 函數功能：給定數組首地址和尾地址，統計數組中元素x的個數，並返回
{
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    return count(first,last,x);
    /********** End **********/
}

bool Equal(int *arr1, int n1, int *arr2)
// 函數功能：給定數組arr1，個數n1，數組arr2，(兩個數組個數相同)，判斷兩個數組是否相等
{
    // 請在這里補充代碼，完成本關任務
    /********** Begin *********/
    bool a;
    for(int i=0;i<n1;i++){
        if(arr1[i]==arr2[i])a=true;
        else {
            a=false;
            break;
        }
    }
    return a;
    /********** End **********/
}