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

2024-09-28 01:17:48

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如何深拷贝(稍微麻烦一点)
}

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

Android 驱动编写LED-NDK程序

1. 首先编写LINUX内核模块LED #include <linux/kernel.h> #include <linux/module.h> #include <linux/fs.h> #include <linux/slab.h> #include <linux/device.h> #include <asm/io.h> #include <asm/uaccess.h> #include <linux/cdev.
Android NDK开发之:配置环境的详解

一.Windows:Windows下的开发环境需要安装以下软件:Java JDK Apache ANT Build SystemAndroid SDKCygwinAndroid NDKEclipse IDE1.安装Java JDKhttp://www.oracle.com/technetwork/java/javase/downloads/index.html配置环境变量:新建一个JAVA_HOME键,值设为JDK的安装目录.打开PATH键,在末尾增加 ;%JAVA_HOME%\bin检测:ja
Android NDK开发的环境搭建与简单示例

一.NDK与JNI简介 NDK全称为native development kit本地语言(C&C++)开发包.而对应的是经常接触的Android-SDK,(software development kit)软件开发包(只支持java语言开发). 简单来说利用NDK,可以开发纯C&C++的代码,然后编译成库,让利用Android-SDK开发的Java程序调用.NDK开发的可以称之为底层开发或者jni(java native interface)层开发,SDK开发可以称为上层开发. Andro
Android NDK 生成以及调用so 文件

1.使用NDK来生成so文件: hello-jni.c 函数名Java +包名+函数名字 2.修改Android.mk文件 LOCAL_SRC_FILES :=hello-jni.c 指定c++文件 3.编译so文件 4.调用so文件 so文件copy到android项目的libs/armeabi目录下最后输出一下结果: 以上就是本篇文章对Android JNI开发流程的梳理,希望可以帮助开发 JNI的朋友.
android开发实践之ndk编译命令简单示例

前言 Android提供了NDK工具,用来编译native代码(c/c++),该工具配置好了相关的交叉编译环境和工具链,只需要你简单地编写几个.mk文件即可将你的c/c++代码编译为Android的java工程/Android手机可以识别.加载和运行的库或者应用程序. 默认情况下,使用NDK编译c/c++代码,需要将该代码放置到任一个Android应用工程的jni目录下,然后编写相应的Android.mk文件,并执行ndk-build命令完成编译.其实你也是可以在任意目录下去编译native代码
Android NDK开发详细介绍

Android之NDK开发一.NDK产生的背景 Android平台从诞生起,就已经支持C.C++开发.众所周知,Android的SDK基于Java实现,这意味着基于Android SDK进行开发的第三方应用都必须使用Java语言.但这并不等同于"第三方应用只能使用Java".在Android SDK首次发布时,Google就宣称其虚拟机Dalvik支持JNI编程方式,也就是第三方应用完全可以通过JNI调用自己的C动态库,即在Android平台上,"Java+C"的
Android开发的IDE、ADT、SDK、JDK、NDK等名词解释

1. IDE: Intelligent Development Environm的简称.即智能开发环境.是一种开发工具.常用的IDE有adt-bundles和Android studio.两个都需要配置jdk. 2. ADT: Android Development tools的简称.即Android开发工具.ADT为Eclipse的插件.在Eclipse和SDK之间起了一个桥梁的作用. 3. SDK: Soft Development Kit的简称.软件开发工具包.在Android中,它为开发
Android NDK开发入门

神秘的Android NDK开发往往众多程序员感到兴奋,但又不知它为何物,由于近期开发应用时,为了是开发的.apk文件不被他人解读(反编译),查阅了很多资料,其中有提到使用NDK开发,怀着好奇的心理,通过在线视频教育网站,我初步了解了NDK的神秘面纱,好东西自然要分享,接下来我们就一起来认识一下Android NDK开发. 一.NDK产生的背景 Android平台从诞生起,就已经支持C.C++开发.众所周知,Android的SDK基于Java实现,这意味着基于Android SDK进行开发的第三
Android NDK开发简单程序分享（Hello Word!）

在之前的博客中已经为大家介绍了,如何在win环境下配置DNK程序,本篇我将带大家实现一个简单的Hello jni程序,让大家真正感受一下NDK开发的魅力.这里我们选择使用C+JAVA开发Android程序,首先你必须了解C语言.JAVA语言以及Linux操作系统,这样可以帮助你开始上手,当然不是说你必须是大牛才能进行NDK开发,下面我们来一起实现一个简单的NDK程序. 第一步,创建Android工程打开开发环境eclipse,在左侧空白区域,右键单击创建Android工程(非常简单,不再赘述)
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 __cp
C++ 数据结构实现两个栈实现一个队列

C++ 数据结构实现两个栈实现一个队列栈为后进先出,队列为先进先出用两个栈实现一个队列.是一个比较经典的问题. 看到这个问题,我的第一个解题思路为: 定义两个栈,s1,s2.s1作为入队列栈,s2作为出队列栈: 入队列:每次入队列的时候,将数值压入s1栈中: 出队列:出队列时,将s1中的所有数据,压进s2栈中,然后删除s2的栈顶数据,然后再将s2中的剩余数据压入s1中. 在这其中s1是一个存储空间,s2是一个辅助空间. 进一步想一下上述办法,在出队列时,每一次都要将s1倒进s2,然后删除s2
数据结构用两个栈实现一个队列的实例

数据结构用两个栈实现一个队列的实例栈是先进后出,队列是先进先出每次元素都push在st1中,pop的时候如果st2为空,将st1的栈顶元素放在st2的栈底,这样st1的所有元素都放在st2中,st1的栈底就是st2的栈顶,pop st2的栈顶,这样就满足了队列的先进先出. #include <iostream> using namespace std; #include <stack> #include <stdlib.h> template <class T
JavaScript数据结构与算法之栈与队列

学习起因曾经有一次在逛V2EX时,碰到这么一个帖子. 数学完全还给老师了,想学回一些基础数学,大概是高中程度的,有什么书籍推荐? 发帖的楼主大学没有高数课程,出去工作时一直在从事前端的工作.感觉到数学知识的匮乏,所以想补一补数学. 看了看帖子,感觉和我很像,因为我的专业是不开高数的,我学的也是前端.也同样感觉到了数学知识匮乏所带来的困顿.同时因为自己的数学思维实在是不怎么好,所以决定努力补习数学与计算机基础知识. 当时也有人说:"前端需要什么数据结构与算法",但是对于这个事情我有自己
Java数据结构之链表、栈、队列、树的实现方法示例

本文实例讲述了Java数据结构之链表.栈.队列.树的实现方法.分享给大家供大家参考,具体如下: 最近无意中翻到一本书,闲来无事写几行代码,实现几种常用的数据结构,以备后查. 一.线性表(链表) 1.节点定义 /**链表节点定义 * @author colonel * */ class Node { public int data; Node next=null; public Node(int data){ this.data=data; } } 2.链表操作类 /**链表操作类 * @auth
Java数据结构专题解析之栈和队列的实现

目录 1. 栈 1.1 概念 1.2 助解图题 1.3 栈的数组实现 1.4 问题 1.5 栈的单链表实现 2. 队列 2.1 概念 2.2 问题 2.3 队列的单链表实现 2.4 数组实现队列 2.5 循环队列 2.6 双端队列 3. 栈和队列练习题 3.1 有效的括号 3.2 用队列实现栈 3.3 用栈实现队列 3.4 实现一个最小栈 3.5 设计循环队列 1. 栈 1.1 概念栈:是一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作. 特点:栈中的数据元素遵循先进后出的原则,但
C语言数据结构链表队列的实现

C语言数据结构链表队列的实现 1.写在前面队列是一种和栈相反的,遵循先进先出原则的线性表. 本代码是严蔚敏教授的数据结构书上面的伪代码的C语言实现代码. 分解代码没有包含在内的代码如下: #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 typedef int QElemtype; typedef int status; 2.代码分解 2.1对队列和节点的结构定义 typedef struct
Java数据结构与算法之栈(动力节点Java学院整理)

stack,中文翻译为堆栈,其实指的是栈,heap,堆.这里讲的是数据结构的栈,不是内存分配里面的堆和栈. 栈是先进后出的数据的结构,好比你碟子一个一个堆起来,最后放的那个是堆在最上面的. 队列就是排队买苹果,先去的那个可以先买. 栈 public class Stack { private int array[]; private int max; private int top; public Stack(int max){ this.max = max; array = new int[m
C#数据结构之队列(Quene)实例详解

本文实例讲述了C#数据结构之队列(Quene).分享给大家供大家参考,具体如下: 队列(Quene)的特征就是"先进先出",队列把所有操作限制在"只能在线性结构的两端"进行,更具体一点:添加元素必须在线性表尾部进行,而删除元素只能在线性表头部进行. 先抽象接口IQuene<T> namespace 栈与队列 { public interface IQuene<T> { /// <summary> /// 取得队列实际元素的个数 /
JS中的算法与数据结构之队列(Queue)实例详解

本文实例讲述了JS中的算法与数据结构之队列(Queue).分享给大家供大家参考,具体如下: 队列(Queue) 我们之前说到了栈,它是一种比较高效的数据结构,遵循先入后出(LIFO,last-in-first-out) 的原则.而今天我们要讨论的队列,它也是一种特殊的列表,它与栈不同的是, 队列只能在队尾插入元素,在队首删除元素,就像我们平时排队买票一样~ 队列用于存储按顺序排列的数据,遵循先进先出(FIFO,First-In-First-Out) 的原则,也是计算机常用的一种数据结构,别用

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

相关推荐

随机推荐