1.0 字符串反转
问题1:给定字符串"hello，world"，实现将其反转。
头插法 输出结果：dlrow，olleh
有一个字符数组里面存储hello，world，通过设置两个指针，一个指针指向字符数组开头begin，一个指针指向字符数组结尾end，在遍历过程当中逐步交换开头和尾部指针所指内容，交换之后移动指针到对应下一个位置，在进行下一次交换，一直到每一个字符都被交换完成，退出条件begin>=end
字符串反转代码实例：
void char_reverse(char* cha)
{
// 指向第一个字符
char* begin = cha;
// 指向最后一个字符
char* end = cha + strlen(cha) - 1;
while (begin < end) {
// 交换前后两个字符,同时移动指针
char temp = *begin;
*(begin++) = *end;
*(end--) = temp;
}
}2.0 链表反转
问题1:单链表反转1234转化为4321?
运用链表的头差法思想来实现单列表的反转，定一个新头节点指针初始化指为null，定义一个临时变量p指针，进行原有链表的遍历，假如现在指的是头节点1，遍历之后首先需要把指针移到第二个位置，把我们定义的新头节点指针指向节点1，1的后面指向null(前提先做p的移动,否则就会丢失原来链表后面部分的内容)，p指向2需要用头差法进行链表反转，需要把2的节点作为新头节点，之后进行p指针的移动p移动到后面把节点2作为新头节点，2的后面是原来节点1，顺次执行，直到新指针遍历为null，就结束了单链表反转。
链表反转代码实例：
// 定义一个链表
struct Node {
int data;
struct Node *next;
};
@interface ReverseList : NSObject
// 链表反转
struct Node* reverseList(struct Node *head);
// 构造一个链表
struct Node* constructList(void);
// 打印链表中的数据
void printList(struct Node *head);
@implementation ReverseList
struct Node* reverseList(struct Node *head)
{
// 定义遍历指针，初始化为头结点
struct Node *p = head;
// 反转后的链表头部
struct Node *newH = NULL;
// 遍历链表
while (p != NULL) {
// 记录下一个结点
struct Node *temp = p->next;
// 当前结点的next指向新链表头部
p->next = newH;
// 更改新链表头部为当前结点
newH = p;
// 移动p指针
p = temp;
}
// 返回反转后的链表头结点
return newH;
}
struct Node* constructList(void)
{
// 头结点定义
struct Node *head = NULL;
// 记录当前尾结点
struct Node *cur = NULL;
for (int i = 1; i < 5; i++) {
struct Node *node = malloc(sizeof(struct Node));
node->data = i;
// 头结点为空，新结点即为头结点
if (head == NULL) {
head = node;
}
// 当前结点的next为新结点
else{
cur->next = node;
}
// 设置当前结点为新结点
cur = node;
}
return head;
}
void printList(struct Node *head)
{
struct Node* temp = head;
while (temp != NULL) {
printf("node is %d \n", temp->data);
temp = temp->next;
}
}
@end3.0 有序数组合并
问题1:数组[1,4,6,7,9] 数组[2,3,5,6,8,10,11,12] 通过算法把两个数组进行合并 合并后仍然是有序的?[1,2,3,4,5,6,6,7,8,9,,10,11,12]
定义两个临时变量，一个p指针指向第一个数组的第一个位置，一个q指针指向第二个数组的第一个位置，做循环遍历来比较p指针和q指针的指向对应数组的位置谁大谁小，如果p的数据小就把它所指向的数据填充到对应新合并的数组结果当中，移动p指针到第一个数组的第二个位置上，q指针不动，之后在比较p指针所指向的内容和q指针指向的内容进行比较，q指针的数据小就把它所指向的数据填充到合并数组结果当中，同时移动q指针到第二个数组的第二个位置，以此类推直到某一个表移动到了结尾，剩下的表无论是p还是q就把所剩下的元素填充到新合并数组中。
算法实现代码实例：
@interface MergeSortedList : NSObject
// 将有序数组a和b的值合并到一个数组result当中，且仍然保持有序
void mergeList(int a[], int aLen, int b[], int bLen, int result[]);
@end@implementation MergeSortedList
void mergeList(int a[], int aLen, int b[], int bLen, int result[])
{
int p = 0; // 遍历数组a的指针
int q = 0; // 遍历数组b的指针
int i = 0; // 记录当前存储位置
// 任一数组没有到达边界则进行遍历
while (p < aLen && q < bLen) {
// 如果a数组对应位置的值小于b数组对应位置的值
if (a[p] <= b[q]) {
// 存储a数组的值
result[i] = a[p];
// 移动a数组的遍历指针
p++;
}
else{
// 存储b数组的值
result[i] = b[q];
// 移动b数组的遍历指针
q++;
}
// 指向合并结果的下一个存储位置
i++;
}
// 如果a数组有剩余
while (p < aLen) {
// 将a数组剩余部分拼接到合并结果的后面
result[i] = a[p++];
i++;
}
// 如果b数组有剩余
while (q < bLen) {
// 将b数组剩余部分拼接到合并结果的后面
result[i] = b[q++];
i++;
}
}
@end4.0 Hash算法
问题1:在一个字符串中找到一个只出现一次的字符？如：输入"abaccdeff",则输出b
字符(char)是一个长度为8的数据类型，因此总共有可能256中可能。
每个字母根据其ASCII码值作为数组的下标对应数组的一个数字。
数组中存储的是每个字符出现的次数。
哈希表
例子：给定值是字符a，对应ASCII值是97，数组索引下标为97。
哈希算法 —— 建立了一个字符到它所储存位置index的映射关系，哈希函数f(key)
f(key)函数通过给定字符转化成对应的ASCII值来确定它在数组当中储存的位置
Hash算法实现代码实例：
@interface HashFind : NSObject
// 查找第一个只出现一次的字符
char findFirstChar(char* cha);
@end
@implementation HashFind
char findFirstChar(char* cha)
{
//定义局部变量result初始化值是空字符 \0是空字符
char result = '\0';
// 定义一个数组 用来存储各个字母出现次数
int array[256];
// 对数组进行初始化操作
for (int i=0; i<256; i++) {
array[i] =0;
}
// 定义一个指针 指向当前字符串头部
char* p = cha;
// 遍历每个字符
while (*p != '\0') {
// 在字母对应存储位置 进行出现次数+1操作
array[*(p++)]++;
}
// 将P指针重新指向字符串头部
p = cha;
// 遍历每个字母的出现次数
while (*p != '\0') {
// 遇到第一个出现次数为1的字符，打印结果
if (array[*p] == 1)
{
result = *p;
break;
}
// 反之继续向后遍历
p++;
}
return result;
}
@end5.0 查找两个子视图的共同父视图？（必考）
问题1:如何查找两个字视图的共同父视图?
查找视图A所有父视图，把所有的superView放到数组里进行保存。
查找视图B所有父视图，把所有的superView放到数组里进行保存。
在通过倒序遍历方式来比较，如果一样就比较下一个superView，直到找到某一个superView不一样的时候，在之前所有一样的superView就是他们全部共同superView。
查找两个字视图的共同父视图代码实例：
@interface CommonSuperFind : NSObject
// 查找两个视图的共同父视图
- (NSArray<UIView *> *)findCommonSuperView:(UIView *)view other:(UIView *)viewOther;
@end
@implementation CommonSuperFind
- (NSArray <UIView *> *)findCommonSuperView:(UIView *)viewOne other:(UIView *)viewOther
{
NSMutableArray *result = [NSMutableArray array];
// 查找第一个视图的所有父视图
NSArray *arrayOne = [self findSuperViews:viewOne];
// 查找第二个视图的所有父视图
NSArray *arrayOther = [self findSuperViews:viewOther];
int i = 0;
// 越界限制条件
while (i < MIN((int)arrayOne.count, (int)arrayOther.count)) {
// 倒序方式获取各个视图的父视图
UIView *superOne = [arrayOne objectAtIndex:arrayOne.count - i - 1];
UIView *superOther = [arrayOther objectAtIndex:arrayOther.count - i - 1];
// 比较如果相等 则为共同父视图
if (superOne == superOther) {
[result addObject:superOne];
i++;
}
// 如果不相等，则结束遍历
else{
break;
}
}
return result;
}
- (NSArray <UIView *> *)findSuperViews:(UIView *)view
{
// 初始化为第一父视图
UIView *temp = view.superview;
// 保存结果的数组
NSMutableArray *result = [NSMutableArray array];
while (temp) {
[result addObject:temp];
// 顺着superview指针一直向上查找
temp = temp.superview;
}
return result;
}
@end6.0 求无序数组当中的中位数
排序算法 + 中位数
利用快排思想
选取关键字，高低交替扫描
任务挑一个元素，以该元素为支点，划分为两部分。
如果左侧集合长度恰为(n-1)/2，那么支点恰为中位数。
如果左侧长度<(n-1)/2,那么中位点在右侧：反之，中位数在左侧。
进入相应的一侧继续寻找中位点循环遍历。
求无序数组当中的中位数代码实例：
@interface MedianFind : NSObject
// 无序数组中位数查找
int findMedian(int a[], int aLen);
@end@implementation MedianFind
//求一个无序数组的中位数
int findMedian(int a[], int aLen)
{
int low = 0;
int high = aLen - 1;
int mid = (aLen - 1) / 2;
int div = PartSort(a, low, high);
while (div != mid)
{
if (mid < div)
{
//左半区间找
div = PartSort(a, low, div - 1);
}
else
{
//右半区间找
div = PartSort(a, div + 1, high);
}
}
//找到了
return a[mid];
}
int PartSort(int a[], int start, int end)
{
int low = start;
int high = end;
//选取关键字
int key = a[end];
while (low < high)
{
//左边找比key大的值
while (low < high && a[low] <= key)
{
++low;
}
//右边找比key小的值
while (low < high && a[high] >= key)
{
--high;
}
if (low < high)
{
//找到之后交换左右的值
int temp = a[low];
a[low] = a[high];
a[high] = temp;
}
}
int temp = a[high];
a[high] = a[end];
a[end] = temp;
return low;
}
@end算法面试总结
问题1:链表反转（重点）
核心在于利用链表的头差法
问题2:有序数组合并
定义两个临时变量，一个p指针指向第一个数组的第一个位置，一个q指针指向第二个数组的第一个位置，做循环遍历来比较p指针和q指针的指向对应数组的位置谁大谁小，如果p的数据小就把它所指向的数据填充到对应新合并的数组结果当中，移动p指针到第一个数组的第二个位置上，q指针不动，之后在比较p指针所指向的内容和q指针指向的内容进行比较，q指针的数据小就把它所指向的数据填充到合并数组结果当中，同时移动q指针到第二个数组的第二个位置，以此类推直到某一个表移动到了结尾，剩下的表无论是p还是q就把所剩下的元素填充到新合并数组中。
问题3:Hash算法
可以通过Hash算法来查找一个字符串中第一个只出现一次的字符。
问题3:查找两个子视图的共同父视图
查找视图A所有父视图，把所有的superView放到数组里进行保存。
查找视图B所有父视图，把所有的superView放到数组里进行保存。
在通过倒序遍历方式来比较，如果一样就比较下一个superView，直到找到某一个superView不一样的时候，在之前所有一样的superView就是他们全部共同superView。
问题4:冒泡排序
(1)，每一趟比较都比较数组中两个相邻元素的大小
(2)，如果i元素小于i-1元素，就调换两个元素的位置
(3)，重复n-1趟的比较
问题5:快速排序
(1). 从数列中挑出一个元素，称为 "基准"（pivot），
(2). 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。
(3). 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
问题6:直接插入排序
实现思路：将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。
问题6:简单选择排序
思路：在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。
问题7:二叉树的先序遍历为FBACDEGH,中序遍历为：ABDCEFGH,请写出这个二叉树的后序遍历结果。
ADECBHGF
先序+中序遍历还原二叉树：先序遍历是：ABDEGCFH 中序遍历是：DBGEACHF
首先从先序得到第一个为A，就是二叉树的根，回到中序，可以将其分为三部分：
左子树的中序序列DBGE，根A，右子树的中序序列CHF
接着将左子树的序列回到先序可以得到B为根，这样回到左子树的中序再次将左子树分割为三部分：
左子树的左子树D，左子树的根B，左子树的右子树GE
同样地，可以得到右子树的根为C
类似地将右子树分割为根C，右子树的右子树HF，注意其左子树为空
如果只有一个就是叶子不用再进行了，刚才的GE和HF再次这样运作，就可以将二叉树还原了。
问题8:什么是堆排序
初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。
问题9:二叉树问题(比较多)
二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”和“右子树”，左子树和右子树同时也是二叉树。二叉树的子树有左右之分，并且次序不能任意颠倒。二叉树是递归定义的，所以一般二叉树的相关题目也都可以使用递归的思想来解决，当然也有一些可以使用非递归的思想解决，我下面列出的一些算法有些采用了递归，有些是非递归的。
什么是二叉排序树？
二叉排序树又叫二叉查找树或者二叉搜索树，它首先是一个二叉树，而且必须满足下面的条件：
1）若左子树不空，则左子树上所有结点的值均小于它的根节点的值；
2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值
3）左、右子树也分别为二叉排序树
4）没有键值相等的节点（？可能是因为不好处理键值相等的节点到底是左节点还是右节点吧）
创建二叉排序树
二叉树中左右节点值本身没有大小之分，所以如果要创建二叉树，就需要考虑如何处理某个节点是左节点还是右节点，如何终止某个子树而切换到另一个子树。 因此我选择了二叉排序树，二叉排序树中对于左右节点有明确的要求，程序可以自动根据键值大小自动选择是左节点还是右节点。
/**
* 创建二叉排序树
* 二叉排序树：左节点值全部小于根节点值，右节点值全部大于根节点值
*
* @param values 数组
*
* @return 二叉树根节点
*/
+ (BinaryTreeNode *)createTreeWithValues:(NSArray *)values {
BinaryTreeNode *root = nil;
for (NSInteger i=0; i<values.count; i++) {
NSInteger value = [(NSNumber *)[values objectAtIndex:i] integerValue];
root = [BinaryTree addTreeNode:root value:value];
}
return root;
}
/**
* 向二叉排序树节点添加一个节点
*
* @param treeNode 根节点
* @param value 值
*
* @return 根节点
*/
+ (BinaryTreeNode *)addTreeNode:(BinaryTreeNode *)treeNode value:(NSInteger)value {
//根节点不存在，创建节点
if (!treeNode) {
treeNode = [BinaryTreeNode new];
treeNode.value = value;
NSLog(@"node:%@", @(value));
}
else if (value <= treeNode.value) {
NSLog(@"to left");
//值小于根节点，则插入到左子树
treeNode.leftNode = [BinaryTree addTreeNode:treeNode.leftNode value:value];
}
else {
NSLog(@"to right");
//值大于根节点，则插入到右子树
treeNode.rightNode = [BinaryTree addTreeNode:treeNode.rightNode value:value];
}
return treeNode;
}二叉树中某个位置的节点
类似索引操作，按层次遍历，位置从0开始算。
/**
* 二叉树中某个位置的节点（按层次遍历）
*
* @param index 按层次遍历树时的位置(从0开始算)
* @param rootNode 树根节点
*
* @return 节点
*/
+ (BinaryTreeNode *)treeNodeAtIndex:(NSInteger)index inTree:(BinaryTreeNode *)rootNode {
//按层次遍历
if (!rootNode || index < 0) {
return nil;
}
NSMutableArray *queueArray = [NSMutableArray array]; //数组当成队列
[queueArray addObject:rootNode]; //压入根节点
while (queueArray.count > 0) {
BinaryTreeNode *node = [queueArray firstObject];
if (index == 0) {
return node;
}
[queueArray removeObjectAtIndex:0]; //弹出最前面的节点，仿照队列先进先出原则
index--; //移除节点，index减少
if (node.leftNode) {
[queueArray addObject:node.leftNode]; //压入左节点
}
if (node.rightNode) {
[queueArray addObject:node.rightNode]; //压入右节点
}
}
//层次遍历完，仍然没有找到位置，返回nil
return nil;
}先序遍历
先访问根，再遍历左子树，再遍历右子树。典型的递归思想。
/**
* 先序遍历
* 先访问根，再遍历左子树，再遍历右子树
*
* @param rootNode 根节点
* @param handler 访问节点处理函数
*/
+ (void)preOrderTraverseTree:(BinaryTreeNode *)rootNode handler:(void(^)(BinaryTreeNode *treeNode))handler {
if (rootNode) {
if (handler) {
handler(rootNode);
}
[self preOrderTraverseTree:rootNode.leftNode handler:handler];
[self preOrderTraverseTree:rootNode.rightNode handler:handler];
}
}中序遍历
先遍历左子树，再访问根，再遍历右子树。
对于二叉排序树来说，中序遍历得到的序列是一个从小到大排序好的序列。
/**
* 中序遍历
* 先遍历左子树，再访问根，再遍历右子树
*
* @param rootNode 根节点
* @param handler 访问节点处理函数
*/
+ (void)inOrderTraverseTree:(BinaryTreeNode *)rootNode handler:(void(^)(BinaryTreeNode *treeNode))handler {
if (rootNode) {
[self inOrderTraverseTree:rootNode.leftNode handler:handler];
if (handler) {
handler(rootNode);
}
[self inOrderTraverseTree:rootNode.rightNode handler:handler];
}
}后序遍历
先遍历左子树，再遍历右子树，再访问根
/**
* 后序遍历
* 先遍历左子树，再遍历右子树，再访问根
*
* @param rootNode 根节点
* @param handler 访问节点处理函数
*/
+ (void)postOrderTraverseTree:(BinaryTreeNode *)rootNode handler:(void(^)(BinaryTreeNode *treeNode))handler {
if (rootNode) {
[self postOrderTraverseTree:rootNode.leftNode handler:handler];
[self postOrderTraverseTree:rootNode.rightNode handler:handler];
if (handler) {
handler(rootNode);
}
}
}层次遍历
按照从上到下、从左到右的次序进行遍历。先遍历完一层，再遍历下一层，因此又叫广度优先遍历。需要用到队列，在OC里可以用可变数组来实现。
/**
* 层次遍历（广度优先）
*
* @param rootNode 二叉树根节点
* @param handler 访问节点处理函数
*/
+ (void)levelTraverseTree:(BinaryTreeNode *)rootNode handler:(void(^)(BinaryTreeNode *treeNode))handler {
if (!rootNode) {
return;
}
NSMutableArray *queueArray = [NSMutableArray array]; //数组当成队列
[queueArray addObject:rootNode]; //压入根节点
while (queueArray.count > 0) {
BinaryTreeNode *node = [queueArray firstObject];
if (handler) {
handler(node);
}
[queueArray removeObjectAtIndex:0]; //弹出最前面的节点，仿照队列先进先出原则
if (node.leftNode) {
[queueArray addObject:node.leftNode]; //压入左节点
}
if (node.rightNode) {
[queueArray addObject:node.rightNode]; //压入右节点
}
}
}二叉树的深度
二叉树的深度定义为：从根节点到叶子结点依次经过的结点形成树的一条路径,最长路径的长度为树的深度。
1）如果根节点为空，则深度为0；
2）如果左右节点都是空，则深度为1；
3）递归思想：二叉树的深度=max（左子树的深度，右子树的深度）+ 1
/**
* 二叉树的深度
*
* @param rootNode 二叉树根节点
*
* @return 二叉树的深度
*/
+ (NSInteger)depthOfTree:(BinaryTreeNode *)rootNode {
if (!rootNode) {
return 0;
}
if (!rootNode.leftNode && !rootNode.rightNode) {
return 1;
}
//左子树深度
NSInteger leftDepth = [self depthOfTree:rootNode.leftNode];
//右子树深度
NSInteger rightDepth = [self depthOfTree:rootNode.rightNode];
return MAX(leftDepth, rightDepth) + 1;
}二叉树的宽度
二叉树的宽度定义为各层节点数的最大值。
/**
* 二叉树的宽度
*
* @param rootNode 二叉树根节点
*
* @return 二叉树宽度
*/
+ (NSInteger)widthOfTree:(BinaryTreeNode *)rootNode {
if (!rootNode) {
return 0;
}
NSMutableArray *queueArray = [NSMutableArray array]; //数组当成队列
[queueArray addObject:rootNode]; //压入根节点
NSInteger maxWidth = 1; //最大的宽度，初始化为1（因为已经有根节点）
NSInteger curWidth = 0; //当前层的宽度
while (queueArray.count > 0) {
curWidth = queueArray.count;
//依次弹出当前层的节点
for (NSInteger i=0; i<curWidth; i++) {
BinaryTreeNode *node = [queueArray firstObject];
[queueArray removeObjectAtIndex:0]; //弹出最前面的节点，仿照队列先进先出原则
//压入子节点
if (node.leftNode) {
[queueArray addObject:node.leftNode];
}
if (node.rightNode) {
[queueArray addObject:node.rightNode];
}
}
//宽度 = 当前层节点数
maxWidth = MAX(maxWidth, queueArray.count);
}
return maxWidth;
}二叉树的所有节点数
递归思想：二叉树所有节点数=左子树节点数+右子树节点数+1
/**
* 二叉树的所有节点数
*
* @param rootNode 根节点
*
* @return 所有节点数
*/
+ (NSInteger)numberOfNodesInTree:(BinaryTreeNode *)rootNode {
if (!rootNode) {
return 0;
}
//节点数=左子树节点数+右子树节点数+1（根节点）
return [self numberOfNodesInTree:rootNode.leftNode] + [self numberOfNodesInTree:rootNode.rightNode] + 1;
}二叉树某层中的节点数
1）根节点为空，则节点数为0；
2）层为1，则节点数为1（即根节点）
3）递归思想：二叉树第k层节点数=左子树第k-1层节点数+右子树第k-1层节点数
/**
* 二叉树某层中的节点数
*
* @param level 层
* @param rootNode 根节点
*
* @return 层中的节点数
*/
+ (NSInteger)numberOfNodesOnLevel:(NSInteger)level inTree:(BinaryTreeNode *)rootNode {
if (!rootNode || level < 1) { //根节点不存在或者level<0
return 0;
}
if (level == 1) { //level=1，返回1（根节点）
return 1;
}
//递归：level层节点数 = 左子树level-1层节点数+右子树level-1层节点数
return [self numberOfNodesOnLevel:level-1 inTree:rootNode.leftNode] + [self numberOfNodesOnLevel:level-1 inTree:rootNode.rightNode];
}二叉树叶子节点数
叶子节点，又叫终端节点，是左右子树都是空的节点。
/**
* 二叉树叶子节点数
*
* @param rootNode 根节点
*
* @return 叶子节点数
*/
+ (NSInteger)numberOfLeafsInTree:(BinaryTreeNode *)rootNode {
if (!rootNode) {
return 0;
}
//左子树和右子树都是空，说明是叶子节点
if (!rootNode.leftNode && !rootNode.rightNode) {
return 1;
}
//递归：叶子数 = 左子树叶子数 + 右子树叶子数
return [self numberOfLeafsInTree:rootNode.leftNode] + [self numberOfLeafsInTree:rootNode.rightNode];
}二叉树最大距离（二叉树的直径）
二叉树中任意两个节点都有且仅有一条路径，这个路径的长度叫这两个节点的距离。二叉树中所有节点之间的距离的最大值就是二叉树的直径。
有一种解法，把这个最大距离划分了3种情况：
1）这2个节点分别在根节点的左子树和右子树上，他们之间的路径肯定经过根节点，而且他们肯定是根节点左右子树上最远的叶子节点（他们到根节点的距离=左右子树的深度）。
2）这2个节点都在左子树上
3）这2个节点都在右子树上
综上，只要取这3种情况中的最大值，就是二叉树的直径。
/**
* 二叉树最大距离（直径）
*
* @param rootNode 根节点
*
* @return 最大距离
*/
+ (NSInteger)maxDistanceOfTree:(BinaryTreeNode *)rootNode {
if (!rootNode) {
return 0;
}
// 方案一：（递归次数较多，效率较低）
//分3种情况：
//1、最远距离经过根节点：距离 = 左子树深度 + 右子树深度
NSInteger distance = [self depthOfTree:rootNode.leftNode] + [self depthOfTree:rootNode.rightNode];
//2、最远距离在根节点左子树上，即计算左子树最远距离
NSInteger disLeft = [self maxDistanceOfTree:rootNode.leftNode];
//3、最远距离在根节点右子树上，即计算右子树最远距离
NSInteger disRight = [self maxDistanceOfTree:rootNode.rightNode];
return MAX(MAX(disLeft, disRight), distance);
}二叉树中某个节点到根节点的路径
既是寻路问题，又是查找节点问题。
定义一个存放路径的栈（不是队列了，但是还是用可变数组来实现的）
1）压入根节点，再从左子树中查找（递归进行的），如果未找到，再从右子树中查找，如果也未找到，则弹出根节点，再遍历栈中上一个节点。
2）如果找到，则栈中存放的节点就是路径所经过的节点。
/**
* 二叉树中某个节点到根节点的路径
*
* @param treeNode 节点
* @param rootNode 根节点
*
* @return 存放路径节点的数组
*/
+ (NSArray *)pathOfTreeNode:(BinaryTreeNode *)treeNode inTree:(BinaryTreeNode *)rootNode {
NSMutableArray *pathArray = [NSMutableArray array];
[self isFoundTreeNode:treeNode inTree:rootNode routePath:pathArray];
return pathArray;
}
/**
* 查找某个节点是否在树中
*
* @param treeNode 待查找的节点
* @param rootNode 根节点
* @param path 根节点到待查找节点的路径
*
* @return YES：找到，NO：未找到
*/
+ (BOOL)isFoundTreeNode:(BinaryTreeNode *)treeNode inTree:(BinaryTreeNode *)rootNode routePath:(NSMutableArray *)path {
if (!rootNode || !treeNode) {
return NO;
}
//找到节点
if (rootNode == treeNode) {
[path addObject:rootNode];
return YES;
}
//压入根节点，进行递归
[path addObject:rootNode];
//先从左子树中查找
BOOL find = [self isFoundTreeNode:treeNode inTree:rootNode.leftNode routePath:path];
//未找到，再从右子树查找
if (!find) {
find = [self isFoundTreeNode:treeNode inTree:rootNode.rightNode routePath:path];
}
//如果2边都没查找到，则弹出此根节点
if (!find) {
[path removeLastObject];
}
return find;
}二叉树中两个节点最近的公共父节点
首先需要明白，根节点肯定是二叉树中任意两个节点的公共父节点（不一定是最近的），因此二叉树中2个节点的最近公共父节点一定在从根节点到这个节点的路径上。因此我们可以先分别找到从根节点到这2个节点的路径，再从这两个路径中找到最近的公共父节点。
/**
* 二叉树中两个节点最近的公共父节点
*
* @param nodeA 第一个节点
* @param nodeB 第二个节点
* @param rootNode 二叉树根节点
*
* @return 最近的公共父节点
*/
+ (BinaryTreeNode *)parentOfNode:(BinaryTreeNode *)nodeA andNode:(BinaryTreeNode *)nodeB inTree:(BinaryTreeNode *)rootNode {
if (!rootNode || !nodeA || !nodeB) {
return nil;
}
if (nodeA == nodeB) {
return nodeA;
}
//从根节点到节点A的路径
NSArray *pathA = [self pathOfTreeNode:nodeA inTree:rootNode];
//从根节点到节点B的路径
NSArray *pathB = [self pathOfTreeNode:nodeB inTree:rootNode];
//其中一个节点不在树中，则没有公共父节点
if (pathA.count == 0 || pathB == 0) {
return nil;
}
//从后往前推，查找第一个出现的公共节点
for (NSInteger i = pathA.count-1; i>=0; i--) {
for (NSInteger j = pathB.count - 1; j>=0; j--) {
if ([pathA objectAtIndex:i] == [pathB objectAtIndex:j]) {
//找到
return [pathA objectAtIndex:i];
}
}
}
return nil;
}二叉树中两个节点之间的路径
从查找最近公共父节点衍生出来的。
/**
* 二叉树中两个节点之间的路径
*
* @param nodeA 第一个节点
* @param nodeB 第二个节点
* @param rootNode 二叉树根节点
*
* @return 两个节点间的路径
*/
+ (NSArray *)pathFromNode:(BinaryTreeNode *)nodeA toNode:(BinaryTreeNode *)nodeB inTree:(BinaryTreeNode *)rootNode {
if (!rootNode || !nodeA || !nodeB) {
return nil;
}
NSMutableArray *path = [NSMutableArray array];
if (nodeA == nodeB) {
[path addObject:nodeA];
[path addObject:nodeB];
return path;
}
//从根节点到节点A的路径
NSArray *pathA = [self pathOfTreeNode:nodeA inTree:rootNode];
//从根节点到节点B的路径
NSArray *pathB = [self pathOfTreeNode:nodeB inTree:rootNode];
//其中一个节点不在树中，则没有路径
if (pathA.count == 0 || pathB == 0) {
return nil;
}
//从后往前推，查找第一个出现的公共节点
for (NSInteger i = pathA.count-1; i>=0; i--) {
[path addObject:[pathA objectAtIndex:i]];
for (NSInteger j = pathB.count - 1; j>=0; j--) {
//找到公共父节点，则将pathB中后面的节点压入path
if ([pathA objectAtIndex:i] == [pathB objectAtIndex:j]) {
j++; //j++是为了避开公共父节点
while (j<pathB.count) {
[path addObject:[pathB objectAtIndex:j]];
j++;
}
return path;
}
}
}
return nil;
}二叉树两个节点之间的距离
/**
* 二叉树两个节点之间的距离
*
* @param nodeA 第一个节点
* @param nodeB 第二个节点
* @param rootNode 二叉树根节点
*
* @return 两个节点间的距离（-1：表示没有找到路径）
*/
+ (NSInteger)distanceFromNode:(BinaryTreeNode *)nodeA toNode:(BinaryTreeNode *)nodeB inTree:(BinaryTreeNode *)rootNode {
if (!rootNode || !nodeA || !nodeB) {
return -1;
}
if (nodeA == nodeB) {
return 0;
}
//从根节点到节点A的路径
NSArray *pathA = [self pathOfTreeNode:nodeA inTree:rootNode];
//从根节点到节点B的路径
NSArray *pathB = [self pathOfTreeNode:nodeB inTree:rootNode];
//其中一个节点不在树中，则没有路径
if (pathA.count == 0 || pathB == 0) {
return -1;
}
//从后往前推，查找第一个出现的公共节点
for (NSInteger i = pathA.count-1; i>=0; i--) {
for (NSInteger j = pathB.count - 1; j>=0; j--) {
//找到公共父节点
if ([pathA objectAtIndex:i] == [pathB objectAtIndex:j]) {
//距离=路径节点数-1 （这里要-2，因为公共父节点重复了一次）
return (pathA.count - i) + (pathB.count - j) - 2;
}
}
}
return -1;
}翻转二叉树
翻转二叉树，又叫求二叉树的镜像，就是把二叉树的左右子树对调（当然是递归的）
/**
* 翻转二叉树（又叫：二叉树的镜像）
*
* @param rootNode 根节点
*
* @return 翻转后的树根节点（其实就是原二叉树的根节点）
*/
+ (BinaryTreeNode *)invertBinaryTree:(BinaryTreeNode *)rootNode {
if (!rootNode) {
return nil;
}
if (!rootNode.leftNode && !rootNode.rightNode) {
return rootNode;
}
[self invertBinaryTree:rootNode.leftNode];
[self invertBinaryTree:rootNode.rightNode];
BinaryTreeNode *tempNode = rootNode.leftNode;
rootNode.leftNode = rootNode.rightNode;
rootNode.rightNode = tempNode;
return rootNode;
}判断二叉树是否完全二叉树
完全二叉树定义为：若设二叉树的高度为h，除第h层外，其它各层的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布。
完全二叉树必须满足2个条件：
1）如果某个节点的右子树不为空，则它的左子树必须不为空
2）如果某个节点的右子树为空，则排在它后面的节点必须没有孩子节点
这里还需要理解“排在它后面的节点”，回头看看层次遍历算法，我们就能知道在层次遍历时，是从上到下从左到右遍历的，先将根节点弹出队列，再压入孩子节点，因此“排在它后面的节点”有2种情况：
1）同层次的后面的节点
2）同层次的前面的节点的孩子节点（因为遍历前面的节点时，会弹出节点，同时将孩子节点压入队列）
通过上面的分析，我们可以设置一个标志位flag，当子树满足完全二叉树时，设置flag=YES。当flag=YES而节点又破坏了完全二叉树的条件，那么它就不是完全二叉树。
/**
* 是否完全二叉树
* 完全二叉树：若设二叉树的高度为h，除第h层外，其它各层的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布
*
* @param rootNode 根节点
*
* @return YES：是完全二叉树，NO：不是完全二叉树
*/
+ (BOOL)isCompleteBinaryTree:(BinaryTreeNode *)rootNode {
if (!rootNode) {
return NO;
}
//左子树和右子树都是空，则是完全二叉树
if (!rootNode.leftNode && !rootNode.rightNode) {
return YES;
}
//左子树是空，右子树不是空，则不是完全二叉树
if (!rootNode.leftNode && rootNode.rightNode) {
return NO;
}
//按层次遍历节点，找到满足完全二叉树的条件：
//条件1：如果某个节点的右子树不为空，则它的左子树必须不为空
//条件2：如果某个节点的右子树为空，则排在它后面的节点必须没有孩子节点
//排在该节点后面的节点有2种：1）同层次的后面的节点 2）同层次的前面的节点的孩子节点（因为遍历前面的节点的时候，会将节点从队列里pop，同时把它的孩子节点push到队列里）
NSMutableArray *queue = [NSMutableArray array];
[queue addObject:rootNode];
BOOL isComplete = NO; //是否已经满足完全二叉树
while (queue.count > 0) {
BinaryTreeNode *node = [queue firstObject];
[queue removeObjectAtIndex:0];
//左子树为空且右子树不为空，则不是完全二叉树
if (!node.leftNode && node.rightNode) {
return NO;
}
if (isComplete && (node.leftNode || node.rightNode)) {
//前面的节点已满足完全二叉树,如果还有孩子节点，则不是完全二叉树
return NO;
}
//右子树为空，则已经满足完全二叉树
if (!node.rightNode) {
isComplete = YES;
}
//压入
if (node.leftNode) {
[queue addObject:node.leftNode];
}
if (node.rightNode) {
[queue addObject:node.rightNode];
}
}
return isComplete;
}判断二叉树是否满二叉树
满二叉树定义为：除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树
满二叉树的一个特性是：叶子数=2^(深度-1)，因此我们可以根据这个特性来判断二叉树是否是满二叉树。
/**
* 是否满二叉树
* 满二叉树：除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树
*
* @param rootNode 根节点
*
* @return YES：满二叉树，NO：非满二叉树
*/
+ (BOOL)isFullBinaryTree:(BinaryTreeNode *)rootNode {
if (!rootNode) {
return NO;
}
//二叉树深度
NSInteger depth = [self depthOfTree:rootNode];
//二叉树叶子节点数
NSInteger leafNum = [self numberOfLeafsInTree:rootNode];
//满二叉树特性：叶子数=2^(深度-1)
if (leafNum == pow(2, (depth - 1))) {
return YES;
}
return NO;
}判断二叉树是否平衡二叉树
平衡二叉树定义为：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树又叫AVL树。
/**
* 是否平衡二叉树
* 平衡二叉树：即AVL树，它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树
*
* @param rootNode 根节点
*
* @return YES：平衡二叉树，NO：非平衡二叉树
*/
+ (BOOL)isAVLBinaryTree:(BinaryTreeNode *)rootNode {
static NSInteger height;
if (!rootNode) {
height = 0;
return YES;
}
if (!rootNode.leftNode && !rootNode.rightNode) {
height = 1;
return YES;
}
BOOL isAVLLeft = [self isAVLBinaryTree:rootNode.leftNode];
NSInteger heightLeft = height;
BOOL isAVLRight = [self isAVLBinaryTree:rootNode.rightNode];
NSInteger heightRight = height;
height = MAX(heightLeft, heightRight)+1;
if (isAVLLeft && isAVLRight && ABS(heightLeft-heightRight) <= 1) {
return YES;
}
return NO;
}
2806
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
