1、使用method

swizzling要注意什么？（进行版本迭代的时候需要进行一些检验，防止系统库的函数发生了变化） 1.避免交换父类方法： 如果当前类未实现被交换的方法而父类实现了的情况下，此时父类的实现会被交换，若此父类的多个继承者都在交换时会导致方法被交换多次而混乱，同时当调用父类的方法时会因为找不到而发生崩溃。 所以在交换前都应该先尝试为当前类添加被交换的函数的新的实现IMP，如果添加成功则说明类没有实现被交换的方法，则只需要替代分类交换方法的实现为原方法的实现，如果添加失败，则原类中实现了被交换的方法，则可以直接进行交换

2、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修饰 **

3、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

4、链表反转

构建一个指定链表 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;
    }
}

5、字符串反转

给定字符串 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;
    }
}