NDK數據結構之隊列與棧等的示例分析

這篇文章主要為大家展示了“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(); 
  } 
 
}

以上是“NDK數據結構之隊列與棧等的示例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！