NDK-CPP语言-常用算法及综合案例

com_tz_ndk_cpp_NDKCpp.h

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_tz_ndk_cpp_NDKCpp */

#ifndef _Included_com_tz_ndk_cpp_NDKCpp
#define _Included_com_tz_ndk_cpp_NDKCpp
#ifdef __cplusplus
extern "C" {
#endif

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppTraverse
        (JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppFind
  (JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSort
        (JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppCopyAndReplace
        (JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppArithmeticAndGenerate
        (JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppGatherArithmetic
        (JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppExample
        (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

com_tz_ndk_cpp_NDKCpp.cpp

#include <iostream>
#import <android/log.h>
#include "com_tz_ndk_cpp_NDKCpp.h"

using namespace std;


//1.C++语言：常用的遍历算法
#include <vector>
#include <algorithm>

void func_print(int v){
    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",v);
}

int increase(int i) {
    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",i);
    return i+1;
}


JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppTraverse
        (JNIEnv *, jobject){
    //1.1 遍历算法
    //函数：for_each()
//    vector<int> vt;
//    vt.push_back(10);
//    vt.push_back(50);
//    vt.push_back(60);
//    vt.push_back(20);
//    vt.push_back(5);
//
//    for_each(vt.begin(),vt.end(),func_print);


    //1.2 遍历算法
    //函数：transform()
    //作用：与for_each类似，遍历所有元素，但可对容器的元素进行修改
//    vector<int> vt;
//    vt.push_back(10);
//    vt.push_back(50);
//    vt.push_back(60);
//    vt.push_back(20);
//    vt.push_back(5);

//    transform(vt.begin(),vt.end(),vt.begin(),increase);
//    for_each(vt.begin(),vt.end(),func_print);

}


//2.C++语言：常用查找算法
#include <set>

//一元谓词
class Func{
public:
    bool operator()(int &v){
        return v < 10;
    }
};

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppFind
        (JNIEnv *, jobject){
    //2.1 查找算法
    //函数：adjacent_find()
    //作用：查找一对相邻重复元素，找到则返回指向这对元素的第一个元素的迭代器
    //     否则返回past-the-end
//    vector<int> vecInt;
//    vecInt.push_back(1);
//    vecInt.push_back(3);
//    vecInt.push_back(2);
//    vecInt.push_back(4);
//    vecInt.push_back(5);
//    vecInt.push_back(5);
//
//    vector<int>::iterator it = adjacent_find(vecInt.begin(),vecInt.end());
//    __android_log_print(ANDROID_LOG_INFO,"main","查找结果：%d",*it);


    //2.2 查找算法
    //函数：binary_search()
    //作用：在<有序序列>中查找value,找到则返回true
    //注意：在<无序序列>中，不可使用
    //set集合默认升序
//    set<int> setInt;
//    setInt.insert(3);
//    setInt.insert(1);
//    setInt.insert(7);
//    setInt.insert(5);
//    setInt.insert(9);

//    vector<int> vecInt;
//    vecInt.push_back(1);
//    vecInt.push_back(2);
//    vecInt.push_back(5);
//    vecInt.push_back(6);
//    vecInt.push_back(8);
//    vecInt.push_back(10);
//
//    bool result = binary_search(vecInt.begin(),vecInt.end(),5);
//    if(result){
//        __android_log_print(ANDROID_LOG_INFO,"main","找到了");
//    }else{
//        __android_log_print(ANDROID_LOG_INFO,"main","没有找到");
//    }
//    for_each(setInt.begin(),setInt.end(),func_print);



    //2.3 查找算法
    //函数：count()
    //作用：查找指定元素在容器出现的次数
    //set集合不允许重复，只存在一个
//    set<int> setInt;
//    setInt.insert(3);
//    setInt.insert(1);
//    setInt.insert(7);
//    setInt.insert(3);
//    setInt.insert(9);

//    vector<int> vecInt;
//    vecInt.push_back(1);
//    vecInt.push_back(2);
//    vecInt.push_back(5);
//    vecInt.push_back(6);
//    vecInt.push_back(8);
//    vecInt.push_back(6);

//    int num = count(setInt.begin(),setInt.end(),3);
//    __android_log_print(ANDROID_LOG_INFO,"main","出现次数：%d",num);


    //2.4 查找函数
    //函数：count_if()
    //作用：自定义查找条件
    //例如：查找大于5的元素个数等条件
//    vector<int> vecInt;
//    vecInt.push_back(1);
//    vecInt.push_back(15);
//    vecInt.push_back(5);
//    vecInt.push_back(6);
//    vecInt.push_back(10);
//    vecInt.push_back(20);
//
//    int num = count_if(vecInt.begin(),vecInt.end(),Func());
//    __android_log_print(ANDROID_LOG_INFO,"main","小于10的个数：%d",num);


    //2.5 查找函数
    //函数：find()
    //作用：对指定范围内的元素与输入值进行比较
    //     当匹配时，结束搜索，返回该元素的迭代器
//    vector<int> vecInt;
//    vecInt.push_back(1);
//    vecInt.push_back(15);
//    vecInt.push_back(5);
//    vecInt.push_back(6);
//    vecInt.push_back(10);
//    vecInt.push_back(20);
//    vector<int>::iterator it = find(vecInt.begin(),vecInt.end(),6);
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it);


    //2.6 查找函数
    //函数：find_if()
    //作用：添加查找条件，返回符合条件的第一个元素
//    vector<int> vecInt;
//    vecInt.push_back(1);
//    vecInt.push_back(15);
//    vecInt.push_back(5);
//    vecInt.push_back(6);
//    vecInt.push_back(10);
//    vecInt.push_back(20);
//
//    //查找小于10的一个元素
//    vector<int>::iterator it = find_if(vecInt.begin(),vecInt.end(),Func());
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it);
}



//3.C++语言：常用的排序算法
class CStudent{
public:
    CStudent(int iID, string strName) {
        this->m_iID = iID;
        this->m_strName = strName;
    }
public:
    int m_iID;
    string m_strName;
};
//学号比较函数
bool Compare(const CStudent &stuA,const CStudent &stuB) {
    return stuA.m_iID < stuB.m_iID;
}

void func_print_student(CStudent &stu){
    __android_log_print(ANDROID_LOG_INFO,"main","编号：%d   姓名：%s",stu.m_iID,stu.m_strName.c_str());
}

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSort
        (JNIEnv *, jobject){
    //3.1 排序算法
    //函数：merge()
    //作用：合并两个容器
    //注意：合并两个<有序序列>
//    vector<int> vecIntA;
//    vecIntA.push_back(1);
//    vecIntA.push_back(3);
//    vecIntA.push_back(5);
//    vecIntA.push_back(7);
//
//    vector<int> vecIntB;
//    vecIntB.push_back(2);
//    vecIntB.push_back(4);
//    vecIntB.push_back(6);
//    vecIntB.push_back(10);
//
//    vector<int> vecIntC;
//    vecIntC.resize(vecIntA.size() + vecIntB.size());
//    //合并
//    merge(vecIntA.begin(),vecIntA.end(),vecIntB.begin(),vecIntB.end(),vecIntC.begin());
//    for_each(vecIntC.begin(),vecIntC.end(),func_print);


    //3.2 排序算法
    //函数：sort()
    //作用：以默认升序的方式重新排列指定范围内的元素。若要改排序规则，可以输入比较函数
//    vector<CStudent> vecStu;
//    vecStu.push_back(CStudent(2,"迷离同学"));
//    vecStu.push_back(CStudent(1,"相约98"));
//    vecStu.push_back(CStudent(3,"陈国军"));
//    vecStu.push_back(CStudent(4,"Jackey"));
//
//    sort(vecStu.begin(),vecStu.end(),Compare);
//    for_each(vecStu.begin(),vecStu.end(),func_print_student);


    //3.3 排序算法
    //函数：random_shuffle()
    //作用：对指定范围内的元素随机调整次序(根据指定的范围进行随机排序)
    //总结：在NDK环境下，不需要指定随机数种子，默认每一次随机排列
    //     在其他C++开发环境中，不能够保证每一次都是随机的，需要动手的指定

    //设置随机种子
//    srand(time(0));
//
//    vector<int> vecIntA;
//    vecIntA.push_back(1);
//    vecIntA.push_back(3);
//    vecIntA.push_back(5);
//    vecIntA.push_back(7);
//
//    random_shuffle(vecIntA.begin(),vecIntA.end());
//    for_each(vecIntA.begin(),vecIntA.end(),func_print);


    //3.4 排序算法
    //函数：reverse()
    //作用：将容器元素倒序排列
//    vector<int> vecIntA;
//    vecIntA.push_back(1);
//    vecIntA.push_back(3);
//    vecIntA.push_back(5);
//    vecIntA.push_back(7);
//    reverse(vecIntA.begin(),vecIntA.end());
//    for_each(vecIntA.begin(),vecIntA.end(),func_print);

}


//4.C++语言：常用的拷贝和替换算法
bool func_replace_if(int &v){
    return v < 5;
}

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppCopyAndReplace
        (JNIEnv *, jobject){
    //4.1 拷贝算法
    //函数：copy()
    //作用：将A容器中的元素拷贝到B容器中(同时也是替换)
//    vector<int> vecIntA;
//    vecIntA.push_back(1);
//    vecIntA.push_back(3);
//    vecIntA.push_back(5);
//    vecIntA.push_back(7);
//    vecIntA.push_back(9);
//
//    vector<int> vecIntB;
//    vecIntB.resize(vecIntA.size());
    vecIntB.push_back(10);
    vecIntB.push_back(30);
    vecIntB.push_back(50);
    vecIntB.push_back(70);
    vecIntB.push_back(90);
//
//
//    //拷贝
//    copy(vecIntA.begin(), vecIntA.end(), vecIntB.begin());
//    for_each(vecIntA.begin(),vecIntA.end(),func_print);


    //4.2 替换函数
    //函数：replace()
    //作用：将指定范围内的容器中的元素替换为我们指定的新的元素
//    vector<int> vecIntA;
//    vecIntA.push_back(1);
//    vecIntA.push_back(3);
//    vecIntA.push_back(5);
//    vecIntA.push_back(3);
//    vecIntA.push_back(9);
//
//    将容器中所有的3，替换为100
//    replace(vecIntA.begin(),vecIntA.end(),3,100);
//    for_each(vecIntA.begin(),vecIntA.end(),func_print);


    //4.3 替换函数
    //函数：replace_if()
    //自定义替换的条件
//    vector<int> vecIntA;
//    vecIntA.push_back(1);
//    vecIntA.push_back(3);
//    vecIntA.push_back(5);
//    vecIntA.push_back(3);
//    vecIntA.push_back(9);
//
//    //需求：将容器中所有小于5的元素替换为99
//    replace_if(vecIntA.begin(),vecIntA.end(),func_replace_if,99);
//    for_each(vecIntA.begin(),vecIntA.end(),func_print);

    //4.4 交互函数
    //函数：swap()
    //作用：将A容器中的元素和B容器中的元素进行互换
//    vector<int> vecIntA;
//    vecIntA.push_back(1);
//    vecIntA.push_back(3);
//    vecIntA.push_back(5);
//
//    vector<int> vecIntB;
//    vecIntB.push_back(20);
//    vecIntB.push_back(30);
//    vecIntB.push_back(50);
//
//    swap(vecIntA,vecIntB);
//
//    for_each(vecIntA.begin(),vecIntA.end(),func_print);
//    for_each(vecIntB.begin(),vecIntB.end(),func_print);


}



//5.C++语言：常用的算术和生成算法
#include <numeric>
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppArithmeticAndGenerate
        (JNIEnv *, jobject){

    //5.1 算术算法
    //函数：accumulate()
    //作用：对指定范围内的元素求和，然后结果再加上一个由val指定的初始值
//    vector<int> vecIntA;
//    vecIntA.push_back(1);
//    vecIntA.push_back(3);
//    vecIntA.push_back(5);
//
//    int sum = accumulate(vecIntA.begin(),vecIntA.end(),100);
//    __android_log_print(ANDROID_LOG_INFO,"main","求和：%d",sum);


    //5.2 生成算法
    //函数：fill()
    //作用：将输入值赋给指定范围内的所有元素
//    vector<int> vecIntA;
//    vecIntA.push_back(1);
//    vecIntA.push_back(3);
//    vecIntA.push_back(5);
//
//    fill(vecIntA.begin(),vecIntA.begin()+1,100);
//    for_each(vecIntA.begin(),vecIntA.end(),func_print);


}


//6.C++语言：常用的集合算法
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppGatherArithmetic
        (JNIEnv *, jobject){
    vector<int> vecIntA;
    vecIntA.push_back(1);
    vecIntA.push_back(3);
    vecIntA.push_back(5);
    vecIntA.push_back(7);
    vecIntA.push_back(9);

    vector<int> vecIntB;
    vecIntB.push_back(1);
    vecIntB.push_back(3);
    vecIntB.push_back(5);
    vecIntB.push_back(6);
    vecIntB.push_back(8);

    vector<int> vecIntC;
    vecIntC.resize(10);

    //set_union
    //作用：并集(构造一个有序序列，包含两个有序序列的并集)
    //并集：
    //例如：集合A(1、3、5)  集合B(1、6、7)  求A和B并集，得到新的集合C(1、3、5、6、7)
//    set_union(vecIntA.begin(), vecIntA.end(), vecIntB.begin(), vecIntB.end(), vecIntC.begin());
//    for_each(vecIntC.begin(),vecIntC.end(),func_print);

    //set_intersection
    //作用：交集(构造一个有序序列，包含两个有序序列的交集)
    //例如：集合A(1、3、5)  集合B(1、6、7)  求A和B交集，得到新的集合C(1)
//    set_intersection(vecIntA.begin(), vecIntA.end(), vecIntB.begin(), vecIntB.end(), vecIntC.begin());
//    for_each(vecIntC.begin(),vecIntC.end(),func_print);

    //set_difference
    //作用：差集(构造一个有序序列，该序列保留第一个有序序列中存在而第二个有序序列中不存在的元素)
    //例如：集合A(1、3、5)  集合B(1、6、7)  求A和B差集，得到新的集合C(3、5)
    set_difference(vecIntA.begin(), vecIntA.end(), vecIntB.begin(), vecIntB.end(), vecIntC.begin());
    for_each(vecIntC.begin(),vecIntC.end(),func_print);

}


//7.C++语言：综合案例
#include <map>
#include <deque>

//1）某市举行一场演讲比赛，共有24个人参加，按参加顺序设置参赛号。比赛共三轮，前两轮为淘汰赛，第三轮为决赛。
//2）比赛方式：分组比赛
//        第一轮
//          分为4个小组，根据参赛号顺序依次划分，比如100-105为一组，106-111为第二组，
//          依次类推，每组6个人，每人分别按参赛号顺序演讲。
//          当小组演讲完后，淘汰组内排名最后的三个选手，然后继续下一个小组的比赛。
//        第二轮
//          分为2个小组，每组6人，每个人分别按参赛号顺序演讲。
//          当小组完后，淘汰组内排名最后的三个选手，然后继续下一个小组的比赛。
//        第三轮
//           只剩下6个人，本轮为决赛，选出前三名。选手每次要随机分组，进行比赛。

//4）比赛评分：
//        10个评委打分，去除最低、最高分，求平均分
//        每个选手演讲完由10个评委分别打分。该选手的最终得分是去掉一个最高分和一个最低分，
//        求得剩下的8个成绩的平均分。选手的名次按得分降序排列，若得分一样，按参赛号升序排名。
//
//用STL编程，求解一下问题
//    要求一：请打印出所有选手的名字与参赛号，并以参赛号的升序排列。
//    要求二：打印每一轮比赛前，分组情况
//    要求三：打印每一轮比赛后，小组晋级名单
//    要求四：打印决赛前三名，选手名称、成绩

#define LOG_I_ARG(FORMAT,...) __android_log_print(ANDROID_LOG_INFO,"main",FORMAT,__VA_ARGS__);
#define LOG_I(FORMAT) LOG_I_ARG(FORMAT,0)

//参赛者
class Sparker{
public:
    //编号
    int num = 100;
    //姓名
    string name = "";
    //积分（保存当前参赛者的积分，有三轮）
    int score[3] = {0};

};

bool sparker_sort(int first,int second){
    return first < second;
}


//产生参赛者
void create_sparker(map<int,Sparker> &sparkerMap,vector<int> &vt_start){
    //这个字符用于参赛者的名称
    string str = "ABCDEFJHIJKLMNOPQRSTUVWX";
    //随机打乱字符串排序
    random_shuffle(str.begin(),str.end());

    //循环产生参赛者
    for (int i = 0; i < 24; ++i) {
        Sparker sparker;
        sparker.num = 100 + i;
        sparker.name = "选手";
        sparker.name = sparker.name + str[i];
        //添加
        sparkerMap.insert(pair<int,Sparker>(sparker.num,sparker));
        vt_start.push_back(sparker.num);
    }
}


//输出所有的参赛者
void print_sparker(map<int,Sparker> &sparkerMap){
    LOG_I("所有的参赛者名单如下：");
    LOG_I("编号   姓名");
    for (map<int,Sparker>::iterator it = sparkerMap.begin(); it != sparkerMap.end();++it) {
        LOG_I_ARG("%d   %s",(*it).second.num,(*it).second.name.c_str());
    }
}

//抽签：按照抽签的顺序比赛
void sparker_drow(vector<int> &vt){
    //随机打乱
    random_shuffle(vt.begin(),vt.end());
}

//开始比赛
//参数一：表示第几轮比赛
//参数二：参赛者
//参数三：开始比赛参赛者编号容器
//参数四：比赛的结果编号容器
void sparker_game(int index,map<int,Sparker> &sparkerMap,vector<int> &vt_start,vector<int> &vt_result){
    //打印当前是第几轮比赛
    LOG_I_ARG("第%d轮开始比赛",index+1);

    //保存评委分数
    deque<int> dq_score;

    //保存分组容器
    //key:表示分数  value:参赛者编号
    //注意：Andorid Studio NDK下'> >'空格分开,编译器认为你是一个位运算符,不分开编译报错
    multimap<int,int,greater<int> > groupMap;


    //用于存储重复的分数对应的编号(编号不会重复)
    //从大到小排列(例如：115  114 113等......)
    set<int,greater<int> > groupSet;
    //单独采用set集合存储积分，用于处理重复的积分
    multiset<int,greater<int> > scoreSet;

    //统计当前是第几组
    int groupNum = 1;

    for (int i = 0; i < vt_start.size(); ++i) {
        //获取参赛者编号
        int num = vt_start.at(i);
        //获取参赛者对象
        Sparker sparker = sparkerMap.at(num);

        //中间省略过程

        //评委打分(10个评委进行打分)
        //分数如何保存，而且要求去掉最高分和最低分
        //采用双向队列方式进行存储:deque
        for (int i = 0; i < 10; ++i) {
            //随机产生评委分数(分数范围：1-100分)
            int score = 1 + rand() % 10;
            dq_score.push_back(score);
        }

        //排序
        sort(dq_score.begin(),dq_score.end());

        //去掉最高分和最低分
        //最高分(第一个元素)
        dq_score.pop_front();
        //最低分(最后一个元素)
        dq_score.pop_back();

        //首先计算总分
        int sum_score = accumulate(dq_score.begin(),dq_score.end(),0);

        //计算平均分
        int avg_score = sum_score / 8;

        //保存得分
        sparker.score[index] = avg_score;
        //重新赋值
        sparkerMap[num] = sparker;

        //清空评委评分集合
        dq_score.clear();

        //例如
        //第一组：i = 0  1  2  3  4  5
        //第二组：i = 6  7  8  9  10 11
        //第三组：i = 12 13 14 15 16 17
        //第四组：i = 18 19 20 21 22 23
        groupMap.insert(pair<int,int>(avg_score,num));
        scoreSet.insert(avg_score);

        if ((i+1)%6 == 0){
            //每一组的淘汰最后三名，也是取出前三名
            //每一个分组是不是需要一个容器保存
            //打印每一组比赛前名单
            LOG_I_ARG("第%d轮-第%d组比赛名单如下：",index+1,groupNum);
            LOG_I("编号   姓名   得分");
            for(multimap<int,int,greater<int> >::iterator it = groupMap.begin();it != groupMap.end();++it){
                int key_score = (*it).first;
                int value_num = (*it).second;
                Sparker sp = sparkerMap.at(value_num);
                LOG_I_ARG("%d   %s   %d",sp.num,sp.name.c_str(),key_score);
            }

//            //下标类似于变成了2
//            //问题：第一个和第二个重复   第三个和第四个重复?
//
//            //打印每一组比赛后的名单
//            //淘汰：取出前三名,获取比赛结果，保存到容器vt_result中
//            //稍后解决
//            //首先我们的成绩排序（按照降序排列）
//            //接下来：成绩我也不知道有没有重复
//            //判断重复
//            //通过函数：判断相邻的两个元素是否相等
//            //整理思路：
//            //第一步：判断是否存在两个了相邻的元素相等
//            multimap<int,int,greater<int> >::iterator it_result = adjacent_find(groupMap.begin(),groupMap.end());
//            //获取当前下标
//            int result_index = 0;
//            for(multimap<int,int,greater<int> >::iterator it = groupMap.begin();it != groupMap.end();++it){
//                int key_score = (*it).first;
//                if (key_score == (*it_result).first){
//                    break;
//                }else{
//                    result_index++;
//                }
//            }
//
//
//            if(it_result != groupMap.end() && result_index < 3){
//                //说明存在相邻元素相等的情况
//                //接下来针对编号排序，然后淘汰
//                //第二步：分析相邻的元素有没有超出我们指定范围（出了前三名之后的成绩发生了重复，我们不管）
//                //第三步：由于成绩相等，我们要根据编号排序，排序的内容是相等的参赛者
//                //       对相等的分数对应的参赛者编号进行排序
//                //首先获取相等元素的个数
//                int score_num = count(scoreSet.begin(),scoreSet.end(),(*it_result).first);
//                //其次：进行排序
//                //筛选重复的分数对应的编号
//                while (groupSet.size() < score_num){
//                    groupSet.insert((*it_result).second);
//                    it_result++;
//                }
//
//                //第四步：筛选前三名
//                //第一种情况：如果你是第一个元素开始重复
//                multimap<int,int,greater<int> >::iterator it_begin = groupMap.begin();
//                if(it_result == it_begin){
//                    if(groupSet.size() == 2){
//                        //头部和尾部
//                        //获取第一个
//                        set<int,greater<int> >::iterator it1 = groupSet.begin();
//                        vt_result.push_back(*it1);
//                        set<int,greater<int> >::iterator it2 = it1++;
//                        vt_result.push_back(*it2);
//                        //添加原先分组的容器中的第三个元素
//                        multimap<int,int,greater<int> >::iterator it_third = groupMap.begin();
//                        it_third++;
//                        it_third++;
//                        //取出编号
//                        vt_result.push_back((*it_third).second);
//                    }else{
//                        //统计个数(通过计数控制指针)
//                        int count = 0;
//                        set<int,greater<int> >::iterator it = groupSet.begin();
//                        while (count < 3){
//                            vt_result.push_back(*it);
//                            it++;
//                            count++;
//                        }
//                    }
//                }
//
//                //第二种情况：如果你是第二个元素开始重复
//                it_begin++;
//                if(it_result == it_begin){
//                    //首先保存原始容器中的第一个元素
//                    vt_result.push_back((*groupMap.begin()).second);
//                    //接下来保存重复元素
//                    set<int,greater<int> >::iterator it1 = groupSet.begin();
//                    vt_result.push_back(*it1);
//                    set<int,greater<int> >::iterator it2 = it1++;
//                    vt_result.push_back(*it2);
//                }
//
//                //第三种情况：如果你是第三个元素开始重复
//                it_begin++;
//                if(it_result == it_begin){
//                    //首先添加原来的元素
//                    multimap<int,int,greater<int> >::iterator begin = groupMap.begin();
//                    vt_result.push_back((*begin).second);
//                    multimap<int,int,greater<int> >::iterator begin_2 = begin++;
//                    vt_result.push_back((*begin_2).second);
//                    //添加排序之后的重复的元素
//                    vt_result.push_back(*groupSet.begin());
//                }
//            }else{
//                while (groupMap.size() > 3){
//                    multimap<int,int,greater<int> >::iterator it_first = groupMap.begin();
//                    //保存用户编号
//                    vt_result.push_back((*it_first).second);
//                    groupMap.erase(it_first);
//                }
//            }

            while (groupMap.size() > 3){
                multimap<int,int,greater<int> >::iterator it_first = groupMap.begin();
                //保存用户编号
                vt_result.push_back((*it_first).second);
                groupMap.erase(it_first);
            }


            //编号排序
            sort(vt_result.begin(),vt_result.end());

            groupMap.clear();
            groupSet.clear();
            groupNum++;
        }

    }
}

//打印比赛结果
void print_sparker_game_result(int index,map<int,Sparker> &sparkerMap,vector<int> &vt_result){
    LOG_I_ARG("第%d轮比赛结果公布如下：",index+1);
    LOG_I("编号   姓名   得分");
    //重新来一个集合
    //保存之后在排序
    //在打印
    for(vector<int>::iterator it = vt_result.begin();it != vt_result.end();++it){
        int num = *it;
        Sparker sparker = sparkerMap.at(num);
        LOG_I_ARG("%d   %s   %d",sparker.num,sparker.name.c_str(),sparker.score[index]);
    }
}

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppExample
        (JNIEnv *, jobject){
    //实现要求一
    //第一步：分析数据结构
    //参赛者: 参赛号、名字、分数
    //解决问题：如何保存参赛者？
    //key:代表参赛者编号   value:代表参赛者
    //map集合：不允许重复(参赛者能够重复？不能够重复)
    //刚刚开始:24个人
    vector<int> vt_start;
    map<int,Sparker> sparkerMap;

    //第二步：随机产生参赛者(24个人)
    create_sparker(sparkerMap,vt_start);
    print_sparker(sparkerMap);


    //实现要求二：打印每一轮比赛前，分组情况
    //开始比赛

    //第三步：分析
    //问题：每一轮选手都是随机
    //我们将每一轮选手都要进行保存
    //我们保存每一轮选手的编号即可
    //定义四个结合，分别保存每一轮选手编号
    //第一轮结果：12个人
    vector<int> vt_frist;
    //第二轮结果：6个人
    vector<int> vt_second;
    //第三轮结果：3个人
    vector<int> vt_third;

    //第四步：第一轮比赛开始了
    //抽签上场演讲
    sparker_drow(vt_start);
    //开始比赛
    sparker_game(0,sparkerMap,vt_start,vt_frist);
    //比赛的打印
    print_sparker_game_result(0,sparkerMap,vt_frist);

    //第五步：第二轮比赛开始了
    //抽签上场演讲
    sparker_drow(vt_frist);
    //开始比赛
    sparker_game(1,sparkerMap,vt_frist,vt_second);
    //比赛的打印
    print_sparker_game_result(1,sparkerMap,vt_second);

    //第六步：第三轮比赛开始了
    //抽签上场演讲
    sparker_drow(vt_second);
    //开始比赛
    sparker_game(2,sparkerMap,vt_second,vt_third);
    //比赛的打印
    print_sparker_game_result(2,sparkerMap,vt_third);

}

整理自示例代码