1、系统UI事件的传递机制？
事件传递：当在视图上触发一个事件时，系统首先会判断主窗口（keyWindow）是否能够接受触摸事件，当无法接受处理时，会在子视图中进行逐级查找判断，直到遍历查找出合适的处理视图
事件响应：当事件传递之后，开始进行事件响应，事件响应是沿着事件传递链条反向响应，即从子视图-->父视图（上级响应链）的过程；如果所有视图都无法响应该触摸事件，则系统会直接抛弃该触摸事件
涉及方法：
- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
只要事件一传递给一个控件,这个控件就会调用 注：【不管这个控件能不能处理事件，也不管触摸点在不在这个控件上， 事件都会先传递给这个控件，随后再调用hitTest:withEvent:方法】 当 return nil 时，则表明拦截该视图及子视图的所有事件
- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event
用来判断触发点是否在该视图内部
事件的传递和响应的区别：
事件的传递是从上到下（父控件到子控件）
事件的响应是从下到上（顺着响应者链条向上传递：子控件到父控件)
2、消息传递机制与消息转发流程？
消息传递：
1、接收者根据isa指针查找所属类的“方法列表”（method list）中从上向下遍历。如果能找到与选择子名称相符的方法，就根据IMP指针（IMP:函数指针，保存了方法地址。）跳转到方法的实现代码，调用这个方法的实现。
2、如果在所属类中未找到相符方法，则继续在集成体系中网上查找，然后同上
3、如果在集成体系中都未找到相符方法，就会执行 消息转发 操作
消息转发：
一个完整的消息转发过程会经历三个阶段：
1、动态方法解析（resolveInstanceMethod或resolveClassMethod）：【本类有机会新增一个处理选择子的方法】
2、备选接收者（forwardingTargetForSelecor）
3、完整消息转发（forwardInvocation）
当消息转发之后，依然没有响应该方法时，即会报错无法识别方法的错误 涉及方法：
void objc_msgSend(id self, SEL cmd, ...)
例如：
id returnValue = objc_msgSend(someObject, @selector(messageName:), parameter)
这是一个参数个数可变的函数。能接收两个或两个以上的参数，
第一个参数代表接受者（调用者），
第二个参数代表选择子（方法）。
后续参数就是消息中的那些参数，其顺序不变。
接受者就是调用方法的对象或者类（本质上类也是对象，叫做类对象）。
动态方法解析
+ (BOOL)resolveInstanceMethod : (SEL)selector
+ (BOOL)resolveClassMethod : (SEL)selector
备选接收者
- (id)forwardingTargetForSelector:(SEL)selector
完整消息转发
- (void)forwardInvocation:(NSInvocation *)invocation
3、异步事件如何控制执行顺序？
1、 runLoop
-(void)runLoopTest{
NSURLSessionDataTask *task = [[NSURLSession sharedSession] dataTaskWithRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"https://www.baidu.com"]] completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
NSLog(@"A");
//RunLoop停止 并获取主线程
CFRunLoopStop(CFRunLoopGetMain());
}] ;
[task resume];
CFRunLoopRun();
NSLog(@"B");
}
2、 dispatch_group_notify
-(void)gcdGroupTest{
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_async(group, queue, ^{
NSLog(@"A");
});
//通知执行完毕
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"B");
});
3、 barrier 阻塞
-(void)dispath_barrier_asyncTest{
dispatch_queue_t queue = dispatch_queue_create(0, DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
NSLog(@"A");
});
//barrier 阻塞
dispatch_barrier_async(queue, ^{
NSLog(@"拿到了A的值");
});
dispatch_async(queue, ^{
NSLog(@"B");
});
}
4、NSOperation dependency 操作队列添加依赖
-(void)operationDependencyTest{
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSBlockOperation *p1 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"A");
}];
NSBlockOperation *p2 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"B");
}];
NSBlockOperation *p3 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"C");
}];
//p2 依赖p1
//p3 依赖p2
[p2 addDependency:p1];
[p3 addDependency:p2];
// waitUntilFinished是否阻塞当前线程
[queue addOperations:@[p1,p2,p3] waitUntilFinished:NO];
}
4、__weak和__block修饰符的使用
__block对象在block中是可以被修改、重新赋值的，因为__block 将对象的内存地址指针放到了堆中，是的对象不管是在block的内部还是外部，都能够保证内存地址相同，进而可以被修改
__weak修饰符的对象，作用等同于定义为weak的property。自然不会导致循环引用问题，因为苹果文档已经说的很清楚，当原对象没有任何强引用的时候，弱引用指针也会被设置为nil
__block和__weak修饰符的区别其实是挺明显的：
1.__block不管是ARC还是MRC模式下都可以使用，可以修饰对象，还可以修饰基本数据类型。
2.__weak只能在ARC模式下使用，也只能修饰对象（NSString），不能修饰基本数据类型（int）。
3.__block对象可以在block中被重新赋值，__weak不可以。
4.__block对象在ARC下可能会导致循环引用，非ARC下会避免循环引用，__weak只在ARC下使用，可以避免循环引用
5、枚举中 NS_ENUM 和 NS_OPTIONS 宏来定义的区别？
官方推荐第一种写法
typedef NS_OPTIONS(NSUInteger, UISwipeGestureRecognizerDirection) {
UISwipeGestureRecognizerDirectionNone = 0, //值为0
UISwipeGestureRecognizerDirectionRight = 1 << 0, //值为2的0次方
UISwipeGestureRecognizerDirectionLeft = 1 << 1, //值为2的1次方
UISwipeGestureRecognizerDirectionUp = 1 << 2, //值为2的2次方
UISwipeGestureRecognizerDirectionDown = 1 << 3 //值为2的3次方
};
typedef enum {
UISwipeGestureRecognizerDirectionNone = 0, //值为0
UISwipeGestureRecognizerDirectionRight = 1 << 0, //值为2的0次方
UISwipeGestureRecognizerDirectionLeft = 1 << 1, //值为2的1次方
UISwipeGestureRecognizerDirectionUp = 1 << 2, //值为2的2次方
UISwipeGestureRecognizerDirectionDown = 1 << 3 //值为2的3次方
}UISwipeGestureRecognizerDirection;
官方推荐第一种写法
typedef NS_ENUM(NSInteger, NSWritingDirection) {
NSWritingDirectionNatural = 0, //值为0
NSWritingDirectionLeftToRight = 2, //值为2
NSWritingDirectionRightToLeft //值为3
};
typedef enum {
NSWritingDirectionNatural = -1, //值为-1
NSWritingDirectionLeftToRight = 0, //值为0
NSWritingDirectionRightToLeft = 1 //值为1
}NSWritingDirection;
NS_ENUM为通用枚举，枚举项的值为 NSInteger，若是定义了枚举项其中一项的值后面依次在它的前一项的值上加1
NS_OPTIONS为位移枚举，枚举项的值为NSUInteger，枚举项的值需要像这样表示1 << 0，1 << 1，2的几次方这样，表示需要用到按位或（2个及以上枚举值可多个存在）
注意：
在使用或运算操作两个枚举值时，
C++默认为运算结果的数据类型是枚举的底层数据类型即NSUInteger,
且C++不允许它隐式转换为枚举类型本身，
所以C++模式下定义了NS_OPTIONS宏以保证不出现类型转换
6、@synthesize和@dynamic分别有什么作用？
1、@property有两个对应的词，一个是 @synthesize，一个是 @dynamic。如果 @synthesize和 @dynamic都没写，那么默认的就是@syntheszie var = _var
2、@synthesize 的语义是如果你没有手动实现 setter 方法和 getter 方法，那么编译器会自动为你加上这两个方法，当同时重写 setter、getter 方法时，需要定义 @syntheszie var = _var
3、@dynamic 告诉编译器：属性的 setter 与 getter 方法由用户自己实现，不自动生成。（当然对于 readonly 的属性只需提供 getter 即可）。假如一个属性被声明为 @dynamic var，然后你没有提供 @setter方法和 @getter 方法，编译的时候没问题，但是当程序运行到 instance.var = someVar，由于缺 setter 方法会导致程序崩溃；或者当运行到 someVar = var 时，由于缺 getter 方法同样会导致崩溃。编译时没问题，运行时才执行相应的方法，这就是所谓的动态绑定。
7、copy与mutableCopy的区别？
1. 对非集合类对象的copy操作:
[immutableObject copy] // 浅复制（指针拷贝）
[immutableObject mutableCopy] //深复制（对象拷贝）
[mutableObject copy] //深复制
[mutableObject mutableCopy] //深复制
在非集合类对象中：
对 immutable 对象进行 copy 操作，是指针复制，mutableCopy 操作时内容复制；
对 mutable 对象进行 copy 和 mutableCopy 都是内容复制
2、集合类对象的copy与mutableCopy
[immutableObject copy] // 浅复制
[immutableObject mutableCopy] //单层深复制
[mutableObject copy] //单层深复制
[mutableObject mutableCopy] //单层深复制
在集合类对象中：
对 immutable 对象进行 copy，是指针复制， mutableCopy 是内容复制；
对 mutable 对象进行 copy 和 mutableCopy 都是内容复制。
但是：集合对象的内容复制仅限于对象本身，对象元素仍然是指针复制
8、字符串转数值实现方案：
在将一个字符串转成数值类型之前，需要先对该字符串进行校验，看是否为数值类型字符串，否则无法进行转换。下面列出的为两种校验方案：
方案一：利用谓词校验
/// 使用正则判断是否为数值字符串
/// @param str 原始字符串
- (BOOL)judgeIsNumberStrWithPredicate:(NSString *)str {
if (str.length == 0) {
return NO;
}
NSArray * arr = [str componentsSeparatedByString:@"."];
if (arr.count > 2) { ///< 表示字符串中有多个小数点（.）不满足
return NO;
}
str = [str stringByReplacingOccurrencesOfString:@"." withString:@""];
NSString * regex = @"[0-9]*|-[0-9]";
NSPredicate * pred = [NSPredicate predicateWithFormat:@"SELF MATCHES %@",regex];
if ([pred evaluateWithObject:str]) {
return YES;
}
return NO;
}
方案二：利用系统 NSCharacterSet 类进行校验
/// 使用 NSCharacterSet API 判断是否为数值字符串
/// @param str 原始字符串
- (BOOL)judgeIsNumberStrWithCharacter:(NSString *)str {
str = [str stringByTrimmingCharactersInSet:[NSCharacterSet decimalDigitCharacterSet]];
if (str.length > 0 && ![str isEqualToString:@"."]) { ///< 截取数字之后，还有其他非 “.” 的字符，不满足
return NO;
}
return YES;
}
转换字符串为数值类型调用
- (void)viewDidLoad {
[super viewDidLoad];
NSNumber * n1 = [self numberFromStr:@"100.9898"];
NSNumber * n2 = [self numberFromStr:@"huda01192"];
NSNumber * n3 = [self numberFromStr:@"0393721"];
NSNumber * n4 = [self numberFromStr:@"98372.198.98"];
NSLog(@"\n-------n1 = %@，\n-------n2 = %@，\n-------n3 = %@，\n-------n4 = %@，\n",n1,n2,n3,n4);
///输出：-------n1 = 100.9898，-------n2 = (null)，-------n3 = 393721，-------n4 = (null)，
}
- (NSNumber *)numberFromStr:(NSString *)str {
/// 检验数值字符串，可替换成 [self judgeIsNumberStrWithCharacter:str]
if ([self judgeIsNumberStrWithPredicate:str]) {
NSNumber * num = @([[NSDecimalNumber decimalNumberWithString:str] floatValue]);
return num;
}
return nil;
}
打印输出结果为：
9、动态库加载过程
参考：
www.jianshu.com/p/8aae28612… www.jianshu.com/p/72e34948d… www.jianshu.com/p/5f337da8f…
在+(void)load中进行断点调试发现，运行期间首先系统会调用dyld中的dyldbootstrap文件的start方法。最后start函数执行了一个main函数（这个可以不是我们app中的main函数，而是dyld的）并返回，所以APP的启动流程为：
1、设置运行环境，配置环境变量；（设置了全局一个链接上下文，包括一些回调函数、参数与标志设置信息，还有线程相关的一些配置）
2、加载共享缓存库；（所有默认的动态链接库被合并成一个大的缓存文件，放到/System/Library/Caches/com.apple.dyld/目录下）
3、实例化主程序；（解析MachO`(可执行文件)`文件进行映射，根据映射信息初始化创建镜像并加入到缓存中的镜像列表）
4、加载动态链接库；
5、链接主程序；（链接所有动态库，进行符号修正绑定工作）
6、初始化主程序 `OC, C++`全局变量初始化（`objc_init`调用`_dyld_objc_notify_register `函数）
7、寻找APP的main函数并调用
10、启动时间处理
1、pre-main阶段优化
1、减少ObjC的类膨胀问题，清理没有使用的类，合并松散无用的类；
2、减少静态变量的声明和初始化的分离；
3、移除没有使用的动态库依赖，明确所依赖的frameworks是require还是optional，optional会动态进行额外检查；
4、删除没有用的方法；
5、减少+load函数的实现，并减少在其中操作的逻辑；
2、main阶段优化
1、didFinishLaunchingWithOptions减少不必要的注册方法，或将注册调用延后处理；
2、压缩或减少启动图片；
3、尽量避免或减少阻塞代码的执行，可以利用多线程优化
11、KVO崩溃的情况
1、注册监听，但未实现 - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context 方法
2、多次removeObserver同一个监听【监听添加和移除次数不匹配】
12、weak原理
系统会创建一个全局的weak表(hash（哈希）表），用来存储所有的弱引用数据信息，
其中Key是弱引用所指对象的内存地址，Value是weak指针的内存地址数组，
即：__weak typeof(obj)weakObj = obj;
key为 &obj；
value为 &weakObj；
13、控制异步操作的执行顺序方式
例如：异步任务A、B、C，要求A在B、C之后执行
方式一：GCD串行队列执行
dispatch_sync(dispatch_get_global_queue(0, 0), ^{
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"B");
});
});
dispatch_sync(dispatch_get_global_queue(0, 0), ^{
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"C");
});
});
dispatch_sync(dispatch_get_global_queue(0, 0), ^{
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"A");
});
});
方式二：GCD group 完成
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_group_enter(group);
dispatch_async(queue, ^{
NSLog(@"B");
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_async(queue, ^{
NSLog(@"C");
dispatch_group_leave(group);
});
dispatch_group_notify(group, queue, ^{
dispatch_async(queue, ^{
NSLog(@"A");
});
});
方式三：GCD barrier 栅栏函数
// 自定义队列
dispatch_queue_t que = dispatch_queue_create("frank_queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(que, ^{
NSLog(@"B");
});
dispatch_async(que, ^{
NSLog(@"C");
});
dispatch_barrier_async(que, ^{
NSLog(@"------- 隔离等待 B、C 事件完成");
});
dispatch_async(que, ^{
NSLog(@"A");
});
方式四：NSOption 添加依赖完成
NSOperationQueue * opQue = [[NSOperationQueue alloc] init];
NSBlockOperation * operation1 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"A");
}];
NSBlockOperation * operation2 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"B");
}];
NSBlockOperation * operation3 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"C");
}];
[operation1 addDependency:operation2];
[operation2 addDependency:operation3];
[opQue addOperation:operation1];
[opQue addOperation:operation2];
[opQue addOperation:operation3];
14、使用method
swizzling要注意什么？（进行版本迭代的时候需要进行一些检验，防止系统库的函数发生了变化） 1.避免交换父类方法： 如果当前类未实现被交换的方法而父类实现了的情况下，此时父类的实现会被交换，若此父类的多个继承者都在交换时会导致方法被交换多次而混乱，同时当调用父类的方法时会因为找不到而发生崩溃。 所以在交换前都应该先尝试为当前类添加被交换的函数的新的实现IMP，如果添加成功则说明类没有实现被交换的方法，则只需要替代分类交换方法的实现为原方法的实现，如果添加失败，则原类中实现了被交换的方法，则可以直接进行交换
15、iOS中copy,strong,retain,weak和assign的区别
copy，strong，weak，assign的区别。 可变变量中，copy是重新开辟一个内存，strong，weak，assgin后三者不开辟内存，只是指针指向原来保存值的内存的位置，storng指向后会对该内存引用计数+1，而weak，assgin不会。weak，assgin会在引用保存值的内存引用计数为0的时候值为空，并且weak会将内存值设为nil，assign不会，assign在内存没有被重写前依旧可以输出，但一旦被重写将出现奔溃 不可变变量中，因为值本身不可被改变，copy没必要开辟出一块内存存放和原来内存一模一样的值，所以内存管理系统默认都是浅拷贝。其他和可变变量一样，如weak修饰的变量同样会在内存引用计数为0时变为nil。 容器本身遵守上面准则，但容器内部的每个值都是浅拷贝。
综上所述，当创建property构造器创建变量value1的时候，使用copy，strong，weak，assign根据具体使用情况来决定。value1 = value2，如果你希望value1和value2的修改不会互相影响的就用用copy，反之用strong,weak,assign。如果你还希望原来值C(C是什么见示意图1)为nil的时候，你的变量不为nil就用strong,反之用weak和assign。weak和assign保证了不强引用某一块内存，如delegate我们就用weak表示，就是为了防止循环引用的产生。 另外，我们上面讨论的是类变量，直接创建局部变量默认是Strong修饰
16、iOS-OC实现LRU算法NSDictionary容器（非线程安全)
LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。
设计原理：
核心数据属性
@property (nonatomic, strong) NSMutableDictionary *dict; // 存储数据
@property (nonatomic, strong) NSMutableArray *arrayForLRU; // 对常用key 进行排序记录处理
@property (nonatomic, assign) NSUInteger maxCountLRU; 设置的最大内存数
1、每次进行读取或存储key数据时，将key设置为优先级最高，最近使用的数据，完成LRU算法记录
2、当最大存储数据达到了上限时，根据LRU算法获取最不常用的key，在存储容器中进行删除这些存储的数据
3、然后对新数据进行存储，同时更新LRU算法记录
另外需要配置一些对外接口方法供给调用
设计过程：
FLRUMutableDictionary.h
#import <Foundation/Foundation.h>
#import <Foundation/NSEnumerator.h>
NS_ASSUME_NONNULL_BEGIN
/// 参照 NSMutableDictionary 定义方式
@interface FLRUMutableDictionary<__covariant KeyType, __covariant ObjectType> : NSObject
///< 初始化最大的存储数量
- (instancetype)initWithMaxCountLRU:(NSUInteger)maxCountLRU;
#pragma mark ------- NSDictionary 方法
@property (readonly) NSUInteger count;
- (NSEnumerator*)keyEnumerator;
- (void)enumerateKeysAndObjectsUsingBlock:(void (^)(KeyType key, ObjectType obj, BOOL *stop))block;
#pragma mark ------- NSMutableDictionary 方法
/// 根据key移除某个数据
/// @param aKey 键
- (void)removeObjectForKey:(KeyType)aKey;
/// 设置数据
/// @param anObject 值
/// @param aKey 键
- (void)setObject:(ObjectType)anObject forKey:(KeyType <NSCopying>)aKey;
/// 移除所有数据
- (void)removeAllObjects;
/// 根据多个键移除数据
/// @param keyArray 键数组
- (void)removeObjectsForKeys:(NSArray<KeyType> *)keyArray;
#pragma mark ------- LRUMutableDictionary 方法
// 执行LRU算法，当访问的元素可能是被淘汰的时候，可以通过在block中返回需要访问的对象，会根据LRU机制自动添加到 dic 中
- (ObjectType)objectForKey:(KeyType)aKey returnEliminateObjectUsingBlock:(ObjectType (^)(BOOL maybeEliminate))block;
@end
NS_ASSUME_NONNULL_END
FLRUMutableDictionary.m
#import "FLRUMutableDictionary.h"
#define LRU_RISK_COUNT 0 // 临界值
@interface FLRUMutableDictionary ()
/**
* 数据存储
*/
@property (nonatomic, strong) NSMutableDictionary * dict;
/**
* 记录对应的 key 顺序
*/
@property (nonatomic, strong) NSMutableArray * arrayForLRU;
/**
* 设置最大内存数
*/
@property (nonatomic, assign) NSUInteger maxCountLRU;
@end
@implementation FLRUMutableDictionary
- (instancetype)initWithMaxCountLRU:(NSUInteger)maxCountLRU {
if (self = [super init]) {
_dict = [NSMutableDictionary dictionaryWithCapacity:maxCountLRU];
_arrayForLRU = [NSMutableArray arrayWithCapacity:maxCountLRU];
_maxCountLRU = maxCountLRU;
}
return self;
}
- (NSString *)description {
return [NSString stringWithFormat:@"-----\n数据：%@\n键顺序：%@",self.dict,self.arrayForLRU];
}
#pragma mark - NSDictionary
- (NSUInteger)count {
return [_dict count];
}
- (NSEnumerator *)keyEnumerator {
return [_dict keyEnumerator];
}
- (id)objectForKey:(id)key {
return [self objectForKey:key returnEliminateObjectUsingBlock:^id _Nonnull(BOOL maybeEliminate) {
return nil;
}];
}
- (void)enumerateKeysAndObjectsUsingBlock:(void (^)(id _Nonnull, id _Nonnull, BOOL * _Nonnull))block {
[_dict enumerateKeysAndObjectsUsingBlock:block];
}
#pragma mark - NSMutableDictionary
- (void)removeObjectForKey:(id)aKey {
[_dict removeObjectForKey:aKey];
[self _removeObjectLRU:aKey];
}
- (void)removeAllObjects {
[_dict removeAllObjects];
[self _removeAllObjectLRU];
}
- (void)removeObjectsForKeys:(NSArray *)keyArray {
if (keyArray.count > 0) {
[_dict removeObjectsForKeys:keyArray];
[self _removeObjectsLRU:keyArray];
}
}
- (void)setObject:(id)anObject forKey:(id<NSCopying>)aKey {
BOOL isExist = ([_dict objectForKey:aKey] != nil);
[_dict setObject:anObject forKey:aKey];
if (isExist) { // 存在，调整位置顺序
[self _adjustPositionLRU:aKey];
}else { // 不存在，直接插入
[self _addObjectLRU:aKey];
}
}
#pragma mark - LRUMutableDictionary
- (id)objectForKey:(id)aKey returnEliminateObjectUsingBlock:(id _Nonnull (^)(BOOL))block {
id obj = [_dict objectForKey:aKey];
if (obj) {
[self _adjustPositionLRU:aKey];
}
if (block) {
BOOL maybeElimiate = obj ? NO:YES;
id newObj = block(maybeElimiate);
if (newObj) {
[self setObject:newObj forKey:aKey];
return [_dict objectForKey:aKey];
}
}
return nil;
}
#pragma mark - LRU
/// 判断是否需要开启RLU淘汰
/// @param count 当前存储数量
- (BOOL)_isNeedOpenLRU:(NSUInteger)count {
NSInteger i = (_maxCountLRU - count);
return (i < LRU_RISK_COUNT);
}
/// 添加
- (void)_addObjectLRU:(id)obj {
// 添加记录新值
if (_arrayForLRU.count == 0) {
[_arrayForLRU addObject:obj];
}else {
[_arrayForLRU insertObject:obj atIndex:0];
}
// 超过了算法限制
if ((_maxCountLRU > 0) && (_arrayForLRU.count > _maxCountLRU)) {
[_dict removeObjectForKey:[_arrayForLRU lastObject]];
[_arrayForLRU removeLastObject];
}
}
/// 移动位置
- (void)_adjustPositionLRU:(id)obj {
NSUInteger idx = [_arrayForLRU indexOfObject:obj];
if (idx != NSNotFound) {
[_arrayForLRU removeObjectAtIndex:idx];
[_arrayForLRU insertObject:obj atIndex:0];
}
}
- (void)_removeObjectLRU:(id)obj {
[_arrayForLRU removeObject:obj];
}
- (void)_removeObjectsLRU:(NSArray *)objArr {
[_arrayForLRU removeObjectsInArray:objArr];
}
- (void)_removeAllObjectLRU {
[_arrayForLRU removeAllObjects];
}
@end
17、链表反转
构建一个指定链表 1->3->8->5->4->2，并将其翻转打印
思路：头插法实现链表反转。定义一个新的head指针作为链表的头部指针，定义一个P指针遍历链表，将每次遍历到的元素插入到head指针后。
// 链表反转
struct Node * reverseList(struct Node *head) {
// 定义变量指针，初始化为头结点
struct Node *p = head;
// 反转后的链表头
struct Node *newH = NULL;
while (p != NULL) {
// 记录下一个结点
struct Node *temp = p -> 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 = 0; i < 5; i++) {
struct Node *node = malloc(sizeof(struct Node));
node->data = I;
if (head == NULL) {
head = node;
} 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;
}
}
18、字符串反转
给定字符串 Hello, world, 实现将其反转。输出结果dlrow,olleh。
思路：使用两个指针，一个指向字符串首部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;
}
}
