NDK 数据结构之队列与栈等的实现

NDK 数据结构之队列与栈等的实现

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
/*
 * Class:   com_tz_ndk_cpp_NDKCpp
 * Method:  callCppTest
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppQueue
 (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppQueuePriority
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppStack
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppList
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppListDelete
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppListInsert
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSet
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetReverse
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetSort
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetFind
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMultiSet
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMap
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMapDelete
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMapFind
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMultiMap
    (JNIEnv *, jobject); 

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppVectorCopy
    (JNIEnv *, jobject); 

#ifdef __cplusplus
}
#endif
#endif

com_tz_ndk_cpp_NDKCpp.cpp

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

using namespace std; 

//1.C++语言：queue队列-基本使用
#include <queue>
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppQueue
    (JNIEnv *, jobject){
  //初始化
  queue<char> q;
  //添加元素
  q.push('A');
  q.push('B');
  q.push('C');
  //添加头部
//  q.front() = 'z';
  //添加尾部
//  q.back() = 'D'; 

  //删除操作
  while (!q.empty()){
    __android_log_print(ANDROID_LOG_INFO,"main","值: %c",q.front());
    //删除
    q.pop();
  }
} 

//2.C++语言：queue队列-优先级
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppQueuePriority
    (JNIEnv *, jobject){
  //2.1 添加元素(默认是按照添加的顺序排列)
//  queue<int> q;
//  q.push(10);
//  q.push(50);
//  q.push(20);
//  q.push(5);
//  //打印
//  while (!q.empty()){
//    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",q.front());
//    q.pop();
//  } 

  //2.2 最大值优先级队列(从大到小排列)
//  priority_queue<int> pq1;
//  pq1.push(10);
//  pq1.push(50);
//  pq1.push(20);
//  pq1.push(5);
//  while (!pq1.empty()){
//    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",pq1.top());
//    pq1.pop();
//  } 

  //2.3 最小值优先级队列
  //注意：不同额编译器对语法检查有差别
  //在AS中进行NDK开发>>符号认为运算符,所以为了避免出现这样的情况，请用空格分离'> >'
  priority_queue<int,vector<int>,greater<int> > pq1;
  pq1.push(10);
  pq1.push(50);
  pq1.push(20);
  pq1.push(5);
  while (!pq1.empty()){
    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",pq1.top());
    pq1.pop();
  }
} 

//3.C++语言：stack栈-基本使用
#include <stack>
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppStack
    (JNIEnv *, jobject){
  stack<int> st;
  st.push(10);
  st.push(20);
  st.push(30); 

  while (!st.empty()){
    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",st.top());
    st.pop();
  }
} 

//4.C++语言：list-基本使用
#include <list>
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppList
    (JNIEnv *, jobject){
  list<int> lt;
  //从头部添加
  lt.push_front(10);
  lt.push_front(20);
  lt.push_front(30);
  //从尾部添加
  lt.push_back(40);
  lt.push_back(50);
  lt.push_back(60); 

  //循环遍历
  for (list<int>::iterator it = lt.begin() ; it != lt.end() ; it++){
    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it);
  } 

  list<int>::iterator it = lt.begin();
  //连续相加允许(++)
  //支持'++'、'--'运算符
  it++;
  it--;
  //注意：不支持间断
  //不支持'+'、'-'运算度
//  it = it - 1; 

} 

//5.C++语言：list-删除
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppListDelete
    (JNIEnv *, jobject){
  list<int> lt;
  //从头部添加
  lt.push_front(10);
  lt.push_front(20);
  lt.push_front(30);
  //从尾部添加
  lt.push_back(40);
  lt.push_back(50);
  lt.push_back(60); 

  //方式一
//  list<int>::iterator it = lt.begin();
//  it++;
//  //删除：删除第二个元素
//  lt.erase(it); 

  //方式二
  //删除第二个元素(直接根据内容删除)
//  lt.remove(20); 

  //方式三:区间删除
  //开始位置
  list<int>::iterator it_begin = lt.begin();
  //结束位置
  list<int>::iterator it_end = lt.begin();
  it_end++;
  it_end++;
  //删除元素(如果已经被删除的元素不能够在删除)
  lt.erase(it_begin,it_end); 

  //循环遍历
  for (list<int>::iterator it = lt.begin() ; it != lt.end() ; it++){
    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it);
  }
} 

//6.C++语言：list-插入
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppListInsert
    (JNIEnv *, jobject){
  list<int> lt;
  //从尾部添加
  lt.push_back(40);
  lt.push_back(50);
  lt.push_back(60); 

  //插入
  lt.insert(lt.begin(),30);
  //循环遍历
  for (list<int>::iterator it = lt.begin() ; it != lt.end() ; it++){
    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it);
  }
} 

//7.C++语言：set-基本使用(元素唯一)-默认从小到大排列
//特点一：元素唯一
//特点二：默认从小到大排列
#include <set>
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSet
    (JNIEnv *, jobject){
  set<int> st;
  st.insert(40);
  st.insert(10);
  st.insert(30);
  st.insert(20); 

  //删除
  set<int>::iterator it = st.begin();
  st.erase(it); 

  for (set<int>::iterator it = st.begin() ; it != st.end() ; it++){
    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it);
  } 

} 

//8.C++语言：set-基本使用(元素唯一)-从大到小排列
//set<int,greater<int>>
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetReverse
    (JNIEnv *, jobject){
  set<int,greater<int> > st;
  st.insert(40);
  st.insert(10);
  st.insert(30);
  st.insert(20); 

  for (set<int>::iterator it = st.begin() ; it != st.end() ; it++){
    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it);
  }
} 

//9.C++语言：set-自定义排序规则
//需求：根据学生的成绩进行排序
class Student{
private:
  char* name;
  int score;
public:
  Student(char* name,int score){
    this->name = name;
    this->score = score;
  }
  int getScore(){
    return this->score;
  }
  void printStudent(){
    __android_log_print(ANDROID_LOG_INFO,"main","姓名: %s, 成绩: %d",this->name,this->score);
  }
};
//仿函数
struct Soft{
  //方式一：不写常量
//  bool operator()(Student &left,Student &right){
//    return left.getScore() < right.getScore();
//  }
  //方式二：const修饰
  bool operator()(const Student &left,const Student &right){
    //类型转换
    Student stu_left = const_cast<Student&>(left);
    Student stu_right = const_cast<Student&>(right);
    return stu_left.getScore() < stu_right.getScore();
  }
};
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetSort
    (JNIEnv *, jobject){
  set<Student,Soft> st;
  st.insert(Student("小宇",50));
  st.insert(Student("梦想",59));
  st.insert(Student("song",55));
  st.insert(Student("远方",58));
  st.insert(Student("石桥中化妖",40)); 

  for (set<Student>::iterator it = st.begin() ; it != st.end() ; it++){
    Student stu = const_cast<Student&>(*it);
    stu.printStudent();
  } 

} 

//10.C++语言：set-查找
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetFind
    (JNIEnv *, jobject){
  set<int> st;
  st.insert(10);
  st.insert(20);
  st.insert(30);
  st.insert(40);
  st.insert(50);
  st.insert(60);
  st.insert(70); 

  //方式一
  //查找等于30元素
  //st.find(2); 

  //方式二
  //查找等于或者小余35元素
  //如果存在你输入的值30，那么就返回当前值30(例如：30)
  //如果不存在你查找的值31，那么返回大于31的最近的一个元素指针
  set<int>::iterator it_lower = st.lower_bound(31);
  __android_log_print(ANDROID_LOG_INFO,"main","查找结果: %d",*it_lower); 

  //如果存在你查找的值30,那么就返回大于30最近的一个元素指针40
  //如果不存在你查找的值31，那么就返回大于31最近的一个元素的指针40
  set<int>::iterator it_upper = st.upper_bound(31);
  __android_log_print(ANDROID_LOG_INFO,"main","查找结果: %d",*it_upper); 

  //方式三:既要返回最小也要最大
  pair<set<int>::iterator,set<int>::iterator> p = st.equal_range(30);
  //获取返回的元素
  __android_log_print(ANDROID_LOG_INFO,"main","小: %d",*p.first);
  __android_log_print(ANDROID_LOG_INFO,"main","大: %d",*p.second); 

} 

//11.C++语言：multiset-基本使用
//允许存储重复元素
//默认升序排列
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMultiSet
    (JNIEnv *, jobject){
  //升序
//  multiset<int> mst;
//  mst.insert(10);
//  mst.insert(20);
//  mst.insert(30);
//  mst.insert(10);
//
//  for (multiset<int>::iterator it = mst.begin() ; it != mst.end() ; it++){
//    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",*it);
//  } 

  //降序
//  multiset<int,greater<int> > mst;
//  mst.insert(10);
//  mst.insert(20);
//  mst.insert(30);
//  mst.insert(10);
//
//  for (multiset<int>::iterator it = mst.begin() ; it != mst.end() ; it++){
//    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",*it);
//  } 

  //自定义排序方式
  multiset<Student,Soft> mst;
  mst.insert(Student("小宇",50));
  mst.insert(Student("梦想",59));
  mst.insert(Student("song",55));
  mst.insert(Student("远方",58));
  mst.insert(Student("石桥中化妖",40));
  mst.insert(Student("Dream",40));
  for (multiset<Student>::iterator it = mst.begin() ; it != mst.end() ; it++){
    Student stu = const_cast<Student&>(*it);
    stu.printStudent();
  }
} 

//12.C++语言：map-基本使用
#include <map>
#include <string>
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMap
    (JNIEnv *, jobject){
  map<int,string> mp;
  //方式一：插入数据pair
  mp.insert(pair<int,string>(01,"陈国军"));
  mp.insert(pair<int,string>(02,"Mr.Sunday"));
  mp.insert(pair<int,string>(03,"Studio"));
  mp.insert(pair<int,string>(04,"余祚宁")); 

  //方式二：如果key存在，那么就不添加同时不覆盖，如果不存在，就添加
  pair<map<int,string>::iterator, bool> result = mp.insert(map<int,string>::value_type(04,"相约98"));
  if(result.second){
    __android_log_print(ANDROID_LOG_INFO,"main","添加成功!");
  }else{
    __android_log_print(ANDROID_LOG_INFO,"main","已存在,添加失败!");
  } 

  //方式三：
  mp.insert(make_pair(05,"定定")); 

  //方式四：如果key存在，重复添加会覆盖，如果不存在，那就直接添加
  mp[5] = "石桥中化妖";
  mp[6] = "定定"; 

  for (map<int,string>::iterator it = mp.begin() ; it != mp.end() ; it++){
    //获取key:it->first
    __android_log_print(ANDROID_LOG_INFO,"main","key: %d",it->first);
    //获取value:it->second
    __android_log_print(ANDROID_LOG_INFO,"main","value: %s",it->second.c_str());
  } 

} 

//13.C++语言：map-删除
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMapDelete
    (JNIEnv *, jobject){
  map<int,string> mp;
  mp.insert(pair<int,string>(01,"陈国军"));
  mp.insert(pair<int,string>(02,"Mr.Sunday"));
  mp.insert(pair<int,string>(03,"Studio"));
  mp.insert(pair<int,string>(04,"余祚宁")); 

  //删除
  map<int,string>::iterator it = mp.begin();
  mp.erase(it); 

  //打印
  for (map<int,string>::iterator it = mp.begin() ; it != mp.end() ; it++){
    //获取key:it->first
    __android_log_print(ANDROID_LOG_INFO,"main","key: %d",it->first);
    //获取value:it->second
    __android_log_print(ANDROID_LOG_INFO,"main","value: %s",it->second.c_str());
  }
} 

//14.C++语言：map-查找(equal_range)
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMapFind
    (JNIEnv *, jobject){
  map<int,string> mp;
  mp.insert(pair<int,string>(01,"陈国军"));
  mp.insert(pair<int,string>(02,"Mr.Sunday"));
  mp.insert(pair<int,string>(03,"Studio"));
  mp.insert(pair<int,string>(04,"余祚宁")); 

  //获取大于或者等于2的元素
  pair<map<int,string>::iterator,map<int,string>::iterator> p = mp.equal_range(2);
  //判断是否存在元素
  if(p.first != mp.end()){
    //等于2
    //获取key:it->first
    __android_log_print(ANDROID_LOG_INFO,"main","key: %d",p.first->first);
    //获取value:it->second
    __android_log_print(ANDROID_LOG_INFO,"main","value: %s",p.first->second.c_str()); 

    //大于2元素
    //获取key:it->first
    __android_log_print(ANDROID_LOG_INFO,"main","key: %d",p.second->first);
    //获取value:it->second
    __android_log_print(ANDROID_LOG_INFO,"main","value: %s",p.second->second.c_str());
  }
} 

//15.C++语言：multimap-一对多
//需求：一个用户对应多个订单
class Order{
private:
  char* name;
  int num;
public:
  Order(char* name,int num){
    this->name = name;
    this->num = num;
  }
  void printOrder(){
    __android_log_print(ANDROID_LOG_INFO,"main","订单名称：%s, 订单号：%d",this->name,this->num);
  }
};
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMultiMap
    (JNIEnv *, jobject){ 

  multimap<string,Order> mst;
  mst.insert(make_pair("陈国军",Order("男士外套",01)));
  mst.insert(make_pair("陈国军",Order("户外跑鞋",02))); 

  mst.insert(make_pair("梦想",Order("女士外套",03)));
  mst.insert(make_pair("梦想",Order("女士高跟鞋",02))); 

  mst.insert(make_pair("Dream",Order("女士纱衣",03)));
  mst.insert(make_pair("Dream",Order("女士布鞋",02)));
  mst.insert(make_pair("Dream",Order("女士外套",02)));
  mst.insert(make_pair("Dream",Order("女士裤子",02))); 

  //遍历
//  for (multimap<string,Order>::iterator it = mst.begin() ; it != mst.end() ; it++){
//    //获取key:it->first
//    __android_log_print(ANDROID_LOG_INFO,"main","key: %s",it->first.c_str());
//    //获取value:it->second
//    Order order = const_cast<Order&>(it->second);
//    order.printOrder();
//  } 

  //需求：只获取"梦想"订单
  //获取订单的数量
  int count = mst.count("梦想");
  //打印"梦想"订单:找到
  multimap<string,Order>::iterator it = mst.find("梦想");
  //循环遍历打印
  //计数
  int i = 0;
  while (it != mst.end() && i < count){
    __android_log_print(ANDROID_LOG_INFO,"main","key: %s",it->first.c_str());
    Order order = const_cast<Order&>(it->second);
    order.printOrder();
    i++;
    it++;
  }
} 

//16.C++语言：vector-浅拷贝和深拷贝
class User{
private:
  char* name;
  int age;
public:
  //浅拷贝(默认就是浅拷贝)
  User(char* name,int age){
    //动态分配内存
    this->name = new char[strlen(name)+1];
    strcpy(this->name,name); 

    this->age = age;
  }
  ~User(){
    if(this->name != NULL){
      delete[] this->name;
      this->name = NULL;
      this->age = 0;
    }
  }
  void printUser(){
    __android_log_print(ANDROID_LOG_INFO,"main","名称：%s, 年龄: %d",this->name,this->age);
  } 

  //深拷贝
  User(const User &user){
    //先释放内存
    if(this->name != NULL){
      delete[] this->name;
      this->name = NULL;
      this->age = 0;
    }
    //动态分配内存
    this->name = new char[strlen(user.name)+1];
    strcpy(this->name,user.name);
    this->age = user.age;
  } 

  User& operator=(User &user){
    if(this->name != NULL){
      delete[] this->name;
      this->name = NULL;
      this->age = 0;
    }
    //动态分配内存
    this->name = new char[strlen(user.name)+1];
    strcpy(this->name,user.name);
    this->age = user.age;
    return *this;
  } 

};
//class User{
//private:
//  string* name;
//  int age;
//public:
//  //浅拷贝(默认就是浅拷贝)
//  User(string name,int age){
//    //动态分配内存
//    this->name = new string(const_cast<string&>(name));
//    this->age = age;
//  }
//  ~User(){
//    if(this->name != NULL){
//      delete this->name;
//      this->name = NULL;
//      this->age = 0;
//    }
//  }
//  void printUser(){
//    __android_log_print(ANDROID_LOG_INFO,"main","名称：%s, 年龄: %d",this->name,this->age);
//  }
//
//  //深拷贝
//  User(const User &user){
//    //先释放内存
//    if(this->name != NULL){
//      delete this->name;
//      this->name = NULL;
//      this->age = 0;
//    }
//    //动态分配内存
//    this->name = new string(const_cast<string&>(user.name));
//    this->age = age;
//  }
//
//  User& operator=(User &user){
//    if(this->name != NULL){
//      delete this->name;
//      this->name = NULL;
//      this->age = 0;
//    }
//    //动态分配内存
//    this->name = new string(const_cast<string&>(user.name));
//    this->age = age;
//    return *this;
//  }
//
////};
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppVectorCopy
    (JNIEnv *, jobject){
  vector<User> vt;
  User user("石桥中化妖",18);
  //实参作为形参，需要调用拷贝函数，然后默认是浅拷贝
  vt.push_back(user); 

  //解决方案：深拷贝
  for (vector<User>::iterator it = vt.begin() ; it != vt.end() ; it++){
    User order = const_cast<User&>(*it);
    order.printUser();
  } 

  //作业：string如何深拷贝(稍微麻烦一点)
}

如有疑问请留言或者到本站社区交流讨论，感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！