反转单链表、实现ArrayList
知识点:
1. 腾讯面试题:
-
用 c/c++ 反转单链表
- 输入: 1->2->3->4->5->NULL
- 输出: 5->4->3->2->1->NULL
struct ListNode *reverseList(struct ListNode* head) { struct ListNode *newHead = NULL; struct ListNode *node; while (head != NULL) { //1. 对之前的链表做头删 node = head; head = head->next; //2. 对新链表做头插 node->next = newHead; newHead = node; } return newHead; }
-
用 c/c++ 判断一棵树是否为平衡二叉树 (可以是一棵空树,左右子树的高度差不会超过 1 ,并且左右两棵子树都是一棵平衡二叉树)
/** * 判断一棵树是否是平衡二叉树 */ template <class T> bool isBalanceTree(TreeNode<T> *pNode){ // 可以是一棵空树,左右子树的高度差不会超过 1 ,并且左右两棵子树都是一棵平衡二叉树 if(!pNode) return true; // 左右子树的高度差不会超过 1 int left = getDepthTree(pNode->left); int right = getDepthTree(pNode->right); // 并且左右两棵子树都是一棵平衡二叉树 return abs(left-right) <= 1 && isBalanceTree(pNode->left) && isBalanceTree(pNode->right); }
2. ArrayList 源码分析
重点:如果开发中涉及到模板类,声明和实现要写到同一个类中,hpp = h + cpp/c (编译)
具体代码请看:NDKPractice项目的cpp20
或者请看: jni/20.C++基础-实现Native层的ArrayList
java中ArrayList
知识点:
- 如果未指定容量大小的话,默认容量是
10
- 每次扩容都是扩充的原来的一半
oldCapacity + (oldCapacity >> 1);
代码:
#ifndef JNI20_ARRAYLIST_H
#define JNI20_ARRAYLIST_H
#include <malloc.h>
//------------------------ 声明 ------------------------//
template<class E>
class ArrayList {
private:
// 长度,数组,当前交表
E *array = NULL; // 当前数组指针
int len = 0; // 数组大小
int index = 0; // 当前角标
public:
ArrayList();
ArrayList(int len);
~ArrayList();
ArrayList(const ArrayList& list);
void add(E e);
E remove(int index);
E get(int index);
int size();
private:
void ensureCapacityInternal(int capacity);
void grow(int capacity);
};
//------------------------ 实现 ------------------------//
template <class E>
ArrayList<E>::ArrayList() {}
// 每个方法都得添加
template <class E>
ArrayList<E>::ArrayList(int len) {
if(len <= 0)
return;
this->len = len;
this->array = (E*)malloc(sizeof(E)*len);
}
template <class E>
ArrayList<E>::~ArrayList() {
if(this->array){
free(this->array);
this->array = NULL;
}
}
template <class E>
ArrayList<E>::ArrayList(const ArrayList &list) {
this->len = list.len;
this->index = list.index;
if(this->array){
free(this->array);
}
this->array = malloc(sizeof(E)*list.len);
memcpy(this->array,list.array, sizeof(E)*index);
}
template <class E>
int ArrayList<E>::size() {
return this->index;
}
template <class E>
void ArrayList<E>::add(E e) {
ensureCapacityInternal(index+1); // Increments modCount!!
this->array[index++] = e;
}
template <class E>
void ArrayList<E>::ensureCapacityInternal(int capacity) {
if(this->array == NULL)
capacity = 10;
if(capacity > this->len){
// 创建新数组
grow(capacity);
}
}
template <class E>
void ArrayList<E>::grow(int capacity) {
int new_len = len + (len >> 1); // 扩容 len的一半
if(capacity > new_len){
new_len = capacity;
}
// 创建新的数组
E* new_array = (E*)malloc(sizeof(E)*new_len);
if(this->array){
memcpy(new_array,this->array,sizeof(E)* index); // sizeof(E)*index 字节
// 释放旧的array
free(this->array);
}
this->array = new_array;
this->len = new_len;
}
template <class E>
E ArrayList<E>::get(int index) {
return array[index];
}
template <class E>
E ArrayList<E>::remove(int index) {
E e = array[index];
int numMoved = this->index - index - 1;
for(int i = index; i < index + numMoved ;i++){
array[i] = array[i+1];
}
array[--this->index] = NULL;
return e;
}
#endif // JNI20_ARRAYLIST_H