腾讯-iOS面试题2面-答案

二面

1、OC中对象的结构

在Objective-C中，对象的结构主要包括三个部分：

isa指针：每个Objective-C对象都包含一个指向它的类的isa指针，该指针指向一个描述对象类型的结构体，即类对象或元类对象。
实例变量：实例变量是一个对象存储其属性值的地方，它们按照定义的顺序依次排列在对象的内存布局中。
对象的附加信息：对象的附加信息包括对象的引用计数和其他一些标识信息，用于管理对象的内存管理和运行时行为。

在Objective-C中，对象的内存布局是由编译器和运行时系统共同管理的。编译器在编译时会为每个类生成一个类对象，用于描述类的结构和属性。运行时系统则负责对象的创建、销毁、内存管理和消息传递等运行时行为。

类对象和元类对象也是Objective-C中的对象，它们包含了描述类的结构和方法的信息，以及一些运行时需要的附加信息。类对象和元类对象的内存布局也包含了isa指针、实例变量和附加信息等部分。

总的来说，Objective-C中的对象结构包括isa指针、实例变量和附加信息等部分，它们一起构成了Objective-C对象的内存布局，用于描述对象的类型、属性和行为等信息。

2、多态

多态（Polymorphism）是面向对象编程中的一个重要概念，它允许不同的对象对同一消息做出不同的响应。具体来说，多态是指在编译时无法确定具体调用哪个方法，而在运行时根据对象的实际类型动态确定调用哪个方法。

在面向对象编程中，多态可以通过继承、接口实现和方法重写等方式实现。例如，假设有一个基类Animal和两个子类Dog和Cat，它们都实现了一个名为makeSound的方法，但是每个子类实现的makeSound方法都不同。在使用多态时，可以将一个指向Dog对象的指针赋给一个指向Animal对象的指针，然后调用makeSound方法，这样就可以根据实际对象的类型动态确定调用哪个makeSound方法。

多态的优点在于可以提高代码的可复用性和可扩展性，减少代码的冗余度。它使得程序更加灵活，可以根据需求动态地创建和使用对象，而不是依赖于固定的类类型。同时，多态也是面向对象编程的一个核心概念，它可以帮助程序员更好地理解和设计面向对象的程序结构。

总的来说，多态是面向对象编程中的一个重要概念，它允许不同的对象对同一消息做出不同的响应，提高了代码的可复用性和可扩展性，是面向对象编程的一个核心概念。

3、Ping是什么协议

Ping是一种网络协议，用于测试和诊断网络连接和主机状态。它使用Internet控制消息协议（ICMP）来向目标主机发送一个简单的消息，以测试目标主机是否可达和响应。Ping通常用于测试网络延迟和带宽，以及检测主机是否在线或是否有故障。

Ping协议最初是由Mike Muuss在1983年为Unix系统开发的，它是一种基于文本的协议，可以在命令行界面上使用。在Ping协议中，发送方向目标主机发送一个ICMP Echo Request消息，如果目标主机可达并且正在运行ICMP服务，则它将发送一个ICMP Echo Reply消息作为响应。发送方可以通过计算响应时间来确定网络延迟和带宽，以及检测主机是否在线或是否有故障。

Ping协议已经成为互联网上最常用的网络测试工具之一，几乎所有操作系统都支持Ping命令，包括Windows、Linux、Mac OS和其他Unix系统。Ping命令还可用于测试网络的连通性和带宽，并且在网络故障排除和网络监控中也经常使用。

4、知道MTU吗

MTU是网络通信中的一个重要概念，它代表最大传输单元（Maximum Transmission Unit），指的是在网络通信中每个数据包的最大长度限制。MTU是以字节为单位来计算的，不同类型的网络和协议可能具有不同的MTU大小限制。

在网络通信中，当发送方将数据包发送到接收方时，数据包的大小不能超过MTU的限制，否则数据包将被分成更小的数据包进行传输，这可能会导致网络拥塞和性能下降。因此，了解MTU的大小限制对网络通信非常重要。

在互联网中，标准的以太网MTU大小为1500字节，而其他类型的网络和协议，如WiFi网络和VPN等，可能具有不同的MTU大小限制。在实际使用中，如果数据包的大小超过MTU的限制，则需要进行分片和重组，这会增加网络通信的延迟和开销。

因此，MTU的大小限制是网络通信中需要考虑的一个重要因素，网络管理员和开发人员需要根据不同的网络和协议来设置合适的MTU值，以确保网络通信的性能和可靠性。

5、ARC和MRC的本质区别是什么？

ARC（Automatic Reference Counting）和MRC（Manual Reference Counting）是Objective-C中两种不同的内存管理方式，它们的本质区别在于内存管理的自动化程度和实现方式。

MRC是一种手动内存管理方式，需要开发人员手动管理对象的引用计数，即手动调用retain和release方法来管理每个对象的生命周期。在MRC中，对象引用计数的增加和减少是由开发人员显式控制的，这需要开发人员具备一定的内存管理技能和经验。

ARC则是一种自动内存管理方式，它通过编译器自动插入retain和release方法来管理对象的引用计数。在ARC中，编译器负责自动计算和管理对象的引用计数，从而减少了开发人员的内存管理负担。ARC的引入使得Objective-C代码更加简洁、易读和易于维护，同时也降低了内存泄漏和野指针等错误的风险。

因此，ARC和MRC的本质区别在于内存管理的自动化程度和实现方式。MRC需要开发人员手动管理对象的引用计数，而ARC则通过编译器自动计算和管理对象的引用计数，从而减少了开发人员的内存管理负担。

6、NSThread，GCD，NSOperation相关的。开启一条线程的方法？线程可以取消吗？

在iOS或macOS开发中，NSThread，GCD和NSOperation都是处理多线程编程的常用方式。

开启一条线程的方法：

使用NSThread类：可以使用NSThread的类方法detachNewThreadSelector:toTarget:withObject:来启动一个新线程。示例代码如下：

[NSThread detachNewThreadSelector:@selector(myThreadMethod:) toTarget:self withObject:nil];

其中，myThreadMethod:是在新线程中执行的方法，self表示该方法所属的对象，nil表示该方法没有参数。

使用GCD（Grand Central Dispatch）：可以使用GCD的API来创建并发队列和任务块，如下所示：

dispatch_queue_t queue = dispatch_queue_create("myQueue", NULL);
dispatch_async(queue, ^{
    // 在新线程中执行的代码
});

其中，dispatch_queue_create用于创建一个新的并发队列，dispatch_async用于在队列中添加一个异步任务块。

使用NSOperation和NSOperationQueue：可以使用NSOperation和NSOperationQueue来完成复杂的多线程编程。示例代码如下：

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
    // 在新线程中执行的代码
}];
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation];

其中，blockOperationWithBlock:创建了一个新的NSBlockOperation对象，并在其中添加了需要在新线程中执行的代码块。然后，将该对象添加到NSOperationQueue中。

线程可以取消吗？

在上述三种方式中，都提供了取消线程的方法。具体来说：

使用NSThread类：可以使用NSThread的实例方法cancel来取消线程。需要在myThreadMethod:方法中定期检查线程是否被取消，以便及时退出线程。
使用GCD：可以使用GCD的APIdispatch_cancel来取消正在执行的任务块。需要在任务块中定期检查任务是否被取消，以便及时退出任务块。
使用NSOperation和NSOperationQueue：可以使用NSOperation的实例方法cancel来取消正在执行的操作。需要在操作的main方法中定期检查操作是否被取消，以便及时退出操作。

需要注意的是，取消线程、任务块或操作并不会立即停止它们的执行，而是会将它们标记为已取消状态，需要在代码中检查并处理取消状态，以便及时退出。

7、子线程中调用connection方法，为什么不回调？因为没有加入runloop，执行完任务就销毁了，所以没有回调。

在iOS或macOS开发中，网络请求一般使用NSURLConnection或NSURLSession等API来实现。当在子线程中调用NSURLConnection的方法时，如果不加入runloop，可能会导致请求没有回调的问题。

这是因为NSURLConnection和NSURLSession都是基于runloop来工作的，它们会在runloop中注册回调事件，等待网络请求的响应。如果在子线程中调用这些API而没有加入runloop，那么请求会在子线程中立即执行完毕，而没有等待网络请求的响应，导致没有回调。

解决这个问题的方法是将子线程的runloop启动起来，使得NSURLConnection或NSURLSession能够在其中注册回调事件并等待网络请求的响应。可以通过调用NSRunLoop的实例方法run来启动runloop，示例代码如下：

- (void)startRequestInThread {
    NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:@"http://example.com"]];
    NSURLConnection *connection = [[NSURLConnection alloc] initWithRequest:request delegate:self startImmediately:NO];
    
    // 加入runloop
    [connection scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
    
    // 启动runloop
    [[NSRunLoop currentRunLoop] run];
}

其中，scheduleInRunLoop:forMode:方法将NSURLConnection对象加入到当前子线程的runloop中，run方法启动runloop并等待事件的发生，包括网络请求的响应。

需要注意的是，在使用NSURLConnection或NSURLSession进行网络请求时，建议使用异步方式，以避免阻塞主线程。另外，使用NSURLSession API进行网络请求更加推荐，因为它是iOS 7及以上版本推出的新API，支持更多的功能和更好的性能。

8、MVC和MVVM的区别

MVC（Model-View-Controller）和MVVM（Model-View-ViewModel）是两种常见的软件架构模式。

MVC是一种传统的架构模式，它将应用程序分为三个部分：模型（Model）、视图（View）和控制器（Controller）。模型表示应用程序的数据和业务逻辑，视图表示模型的可视化呈现，控制器协调模型和视图之间的交互，并处理用户输入和系统事件。

MVVM是一种新兴的架构模式，它将应用程序分为三个部分：模型（Model）、视图（View）和视图模型（ViewModel）。模型和视图的定义与MVC相同，视图模型是一个用于连接视图和模型的中间层，它封装了视图和模型之间的交互，提供了一个清晰的接口，以便将视图绑定到模型的数据。

MVC和MVVM的区别在于它们的分层方式和数据流向：

MVC的数据流向是单向的，从模型到视图，而控制器作为中间人，负责将模型的数据传递给视图。而MVVM的数据流向是双向的，视图和视图模型之间通过数据绑定实现双向数据同步。
MVC中，视图和模型之间的关系是直接的，模型直接将数据传递给视图，因此视图需要了解模型的数据结构和业务逻辑。而在MVVM中，视图和视图模型之间的关系是间接的，视图模型封装了模型和视图之间的交互，因此视图只需要了解视图模型的接口，而不需要了解模型的具体实现。
MVVM中，视图模型可以通过命令模式实现用户输入的响应，并处理视图的显示逻辑，从而减少了视图和控制器之间的耦合度。

总的来说，MVVM相对于MVC更加灵活和可扩展，它使得视图和模型之间的交互更加清晰和可控，同时也使得代码更加容易测试和重用。但是，MVVM也需要更多的代码和学习成本，因此在选择架构模式时需要根据具体的项目需求和开发团队的技能水平进行权衡。

9、了解哪些设计模式

单例模式（Singleton）：确保一个类只有一个实例，并提供全局访问点。适用于需要全局管理某些资源或状态的场景。
工厂模式（Factory）：定义一个用于创建对象的接口，让子类决定实例化哪个类。适用于需要动态决定创建哪个对象的场景。
抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。适用于需要创建一组相关对象的场景。
建造者模式（Builder）：将一个复杂对象的构建过程和表示分离，使得同样的构建过程可以创建不同的表示。适用于需要构建复杂对象的场景。
原型模式（Prototype）：通过复制现有对象来创建新对象，而无需知道其具体类。适用于需要创建大量相似对象的场景。
适配器模式（Adapter）：将一个类的接口转换为客户端所期望的另一个接口。适用于需要将不兼容的接口进行转换的场景。
桥接模式（Bridge）：将抽象和实现分离开来，使它们可以独立地变化。适用于需要在抽象和实现之间进行多层次变化的场景。
组合模式（Composite）：将对象组合成树形结构以表示整体-部分的层次结构。适用于需要处理对象的层次结构的场景。
装饰器模式（Decorator）：在不改变原始对象的情况下，动态地添加一些额外的职责。适用于需要动态地扩展对象功能的场景。
外观模式（Facade）：提供一个简单的接口，隐藏系统的复杂性。适用于需要对外提供简单接口的场景。
享元模式（Flyweight）：通过共享对象来减少内存中对象的数量，以达到节省内存的目的。适用于需要大量创建相似对象的场景。
代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。适用于需要控制对象访问权限的场景。

这些设计模式都是经典的面向对象编程技巧，可以帮助开发者更好地组织和管理代码。在实际开发中，根据具体的需求和场景合理地选择和应用设计模式可以提高代码的可维护性、可扩展性和可重用性。

10、存一个通讯录，包括增删改查，用什么数据结构

对于通讯录这种需要增删改查的应用，常用的数据结构是哈希表（Hash Table）或者平衡树（Balanced Tree）。

哈希表是一种基于哈希函数实现的数据结构，它能够快速地进行插入、删除和查找操作，时间复杂度为O(1)。在通讯录中，可以将联系人的姓名作为键值，联系人的详细信息作为值，这样就可以通过姓名快速地查找到对应的联系人。

平衡树是一种自平衡的二叉搜索树，能够保证插入、删除和查找操作的时间复杂度为O(log n)。在通讯录中，可以将联系人的姓名作为键值，联系人的详细信息作为值，这样就可以通过姓名快速地查找到对应的联系人。同时，平衡树还可以支持按照姓名排序，方便进行通讯录的浏览和管理。

选择哈希表还是平衡树，需要根据具体情况来选择。哈希表对于大规模数据的增删改查速度更快，但在数据量较小的情况下，哈希表的优势不太明显。平衡树则适用于需要进行排序和范围查找的场景，但相对来说，平衡树的实现和维护比较复杂，需要消耗更多的时间和空间。

11、autorelease变量什么时候释放？手动添加的是大括号结束的时候释放，系统自动释放是在当前runloop循环结束的时候

autorelease变量是通过将对象添加到当前的自动释放池中来管理对象的内存释放。手动添加的自动释放池使用大括号来定义它的作用范围，当大括号结束时，自动释放池就会释放其中所有的对象。

对于系统自动创建的自动释放池，其生命周期与当前的runloop循环相关。在每个runloop循环中，系统会自动创建一个自动释放池，并在循环结束时释放其中所有的对象。这意味着，如果在一个runloop循环中创建了大量的autorelease变量，这些变量会在当前循环结束时一次性释放，从而避免了内存泄漏的问题。

需要注意的是，autorelease变量的释放仅仅是将对象返回到系统的自动释放池中，而不是立即释放对象的内存。实际的内存释放是由系统在适当的时机进行的，具体的时间取决于系统的内存管理策略和当前的内存使用情况。因此，使用autorelease变量可以避免内存泄漏的问题，但并不能完全解决内存管理的挑战，开发者还需要关注和优化内存使用情况，以确保应用程序的性能和稳定性。

13、那子线程中的autorelease变量什么时候释放？

在子线程中，同样可以使用自动释放池来管理autorelease变量的内存释放。然而，与主线程不同的是，子线程中并不存在默认的自动释放池，因此需要手动创建和管理自动释放池。

在子线程中，可以通过以下方式手动创建自动释放池：

- (void)myThreadMainMethod {
    @autoreleasepool {
        // 代码逻辑
    }
}

当自动释放池作用域结束时，其中的所有autorelease变量都会被释放，内存也会被回收。需要注意的是，子线程中autorelease变量的释放仅仅是将对象返回到自动释放池中，实际的内存释放仍然由系统在适当的时机进行。

需要特别注意的是，在子线程中使用autorelease变量时，必须在手动创建自动释放池之后才能使用，否则这些变量将不会被正确释放，可能导致内存泄漏的问题。

总之，虽然在子线程中使用autorelease变量需要手动管理自动释放池，但使用自动释放池可以有效避免内存泄漏和内存崩溃等问题，提高应用程序的性能和稳定性。

14、子线程里面，需要加autoreleasepool吗

在子线程中，如果使用了autorelease变量，那么需要手动添加自动释放池来确保这些变量能够被正确释放，避免内存泄漏的问题。因此，在子线程中使用autorelease变量时，通常需要手动添加自动释放池。

在使用GCD（Grand Central Dispatch）时，可以使用dispatch_async函数将任务提交到指定的队列中，并在任务的代码块中添加自动释放池，例如：

dispatch_async(myQueue, ^{
    @autoreleasepool {
        // 任务代码块
    }
});

需要注意的是，如果在子线程中没有使用autorelease变量，那么就没有必要手动添加自动释放池，因为在GCD的子线程中，系统会默认创建自动释放池。

总之，在子线程中使用autorelease变量时，需要手动添加自动释放池，以确保这些变量能够被正确释放；如果没有使用autorelease变量，那么就没有必要手动添加自动释放池。

15、GCD和NSOperation的区别？

GCD（Grand Central Dispatch）和NSOperation都是用于多线程编程的技术，它们有以下的区别：

抽象程度不同：NSOperation是基于GCD的更高层次的抽象，它提供了一种面向对象的多线程编程方式，可以更方便地管理任务之间的依赖关系，并支持取消和挂起任务等高级功能。而GCD则是一种更底层的多线程编程技术，它提供了一些基本的操作，如创建队列、提交任务、等待任务完成等，更加轻量级和灵活。
语法形式不同：GCD使用C语言的函数式编程风格，需要手动管理内存和线程同步；而NSOperation基于Objective-C的面向对象编程风格，减少了手动管理内存和线程同步的复杂性。
性能特点不同：GCD更加轻量级和高效，在处理大量简单任务时性能更好；而NSOperation则更适合处理复杂的任务，可以更方便地管理任务之间的依赖关系，支持取消和挂起等高级功能。
可扩展性不同：NSOperation更加可扩展和灵活，可以通过继承NSOperation自定义任务，实现更多的功能；而GCD则更加简单和易用，适用于大多数的多线程场景。

总之，GCD和NSOperation都是用于实现多线程编程的技术，它们各自有自己的优点和适用场景，在实际开发中需要根据具体情况选择合适的技术。

16、项目里面遇到过死锁吗？怎么解决？数据库访问本来就是线程安全的，不会造成死锁啊。什么是死锁？

死锁是指两个或多个线程在互相等待对方所持有的资源时，进入了一种无法继续执行的状态。例如，线程A持有资源X，需要资源Y，而线程B持有资源Y，需要资源X，两个线程都在等待对方先释放资源，导致程序无法继续执行下去，形成死锁。

在数据库访问中，死锁通常是由于多个事务同时访问同一组数据时，通过不同的顺序获取锁导致的。虽然数据库本身是线程安全的，但是在多事务并发的情况下，如果没有正确的锁管理和事务管理，仍然可能会发生死锁。

解决死锁的方法主要有以下几种：

避免循环等待：尽量避免设计出循环等待的情况，例如通过按照一定的顺序获取锁来避免死锁。
资源预分配：尽量减少对共享资源的争用，例如通过预分配资源来避免多个事务同时请求同一组数据。
超时等待：在获取锁时设置超时时间，如果等待时间超过一定时间还没有获取到锁，则放弃当前操作，避免死锁的发生。
死锁检测和恢复：通过定期检测系统是否出现死锁，并采取相应的恢复措施，例如回滚某些事务或者释放某些锁。

总之，死锁是多线程编程中常见的问题，需要通过合理的锁管理和事务管理来避免死锁的发生。在数据库访问中，也需要注意锁管理和事务管理，避免死锁的发生。

17、Viewcontroller的生命周期？

ViewController是iOS中用于控制视图层次结构的基本单元，它的生命周期包括以下几个阶段：

初始化（init）：在创建ViewController对象时，会调用init方法来进行初始化，可以在这里进行一些基本属性的初始化工作。
加载视图（loadView）：在ViewController的view被访问时，会调用loadView方法来加载视图，如果在这个方法中没有手动创建视图，则系统会自动从nib文件或者storyboard中加载视图。
创建视图（viewDidLoad）：在视图加载完成后，会调用viewDidLoad方法来进行视图的进一步初始化工作，例如设置视图的背景颜色、添加子视图等。
视图将要显示（viewWillAppear）：在视图将要显示时，会调用viewWillAppear方法，可以在这里进行一些视图显示前的准备工作。
视图已经显示（viewDidAppear）：在视图已经显示后，会调用viewDidAppear方法，可以在这里进行一些视图显示后的操作，例如开始动画、启动计时器等。
视图将要消失（viewWillDisappear）：在视图将要消失时，会调用viewWillDisappear方法，可以在这里进行一些视图消失前的准备工作，例如停止动画、停止计时器等。
视图已经消失（viewDidDisappear）：在视图已经消失后，会调用viewDidDisappear方法，可以在这里进行一些视图消失后的操作，例如清理资源、释放内存等。
内存警告（didReceiveMemoryWarning）：当系统内存不足时，会调用didReceiveMemoryWarning方法，可以在这里进行一些内存清理工作，例如释放不必要的资源、清空缓存等。
卸载视图（viewWillUnload）：在视图被卸载前，会调用viewWillUnload方法，可以在这里进行一些视图卸载前的清理工作。
销毁（dealloc）：在ViewController对象被销毁时，会调用dealloc方法，可以在这里进行一些资源的释放和清理工作。

总之，ViewController的生命周期包括了多个阶段，每个阶段都提供了相应的方法来进行必要的操作和处理。在开发中，需要根据具体的需求和场景，合理地使用这些方法，以实现视图的正确显示和处理。

18、在init方法里面，设置背景颜色，会生效吗会生效。为什么会？

在init方法中设置背景颜色会生效，但是不会立即显示出来。因为在初始化阶段，视图还没有被加载，也就是说，view属性还没有被创建。所以设置背景颜色不会立即生效。

当视图被访问时，系统会自动调用loadView方法来加载视图，如果在这个方法中没有手动创建视图，则系统会自动从nib文件或者storyboard中加载视图。在这个阶段，视图会被创建，view属性被赋值，此时在init方法中设置的背景颜色才会生效。

如果需要在初始化阶段就设置背景颜色，可以在init方法中创建UIView对象，并将其赋值给view属性，然后设置背景色即可。但是这种方式需要手动创建视图，不建议使用。通常情况下，应该在viewDidLoad方法中进行视图的初始化工作，包括设置背景颜色等。

19、WWDC2016公布了哪些新特性？对苹果系列的最新特性有关注吗

WWDC2016是苹果开发者大会的一次，主要公布了以下新特性：

iOS 10：iOS 10带来了许多新特性，包括更加智能的Siri、扩展的第三方应用支持、全新的消息应用和相册应用、更加丰富的地图应用等。
macOS Sierra：macOS Sierra是苹果操作系统的最新版本，它引入了Siri、iCloud桌面与文稿、自动解锁等新特性，还支持Safari浏览器的图片和视频播放、Apple Pay在线购物等功能。
watchOS 3：watchOS 3是苹果手表操作系统的最新版本，它改进了表盘、应用、消息、运动等方面的功能，提高了表现速度和用户体验。
tvOS 10：tvOS 10是苹果电视操作系统的最新版本，它引入了全新的“单点登录”功能、“即将上映”电影预告片、支持多用户游戏等新特性。

20、看过哪些源码，讲讲思路

AFNetworking是一个流行的iOS网络库，它简化了iOS应用程序的网络通信，提供了丰富的API和工具，使得网络通信变得更加高效和简单。AFNetworking采用了Objective-C语言编写，支持iOS、macOS、watchOS和tvOS等平台。

AFNetworking的主要特点包括：

支持多种网络协议：AFNetworking支持HTTP、HTTPS、WebSocket等多种网络协议，可以方便地进行数据传输和通信。
提供丰富的API和工具：AFNetworking提供了丰富的API和工具，包括NSURLConnection、NSURLSession、AFHTTPClient、AFHTTPRequestOperation等，可以满足不同场景下的网络通信需求。
支持缓存和离线模式：AFNetworking支持缓存和离线模式，可以在网络不可用时自动使用缓存数据，提高应用程序的稳定性和用户体验。
支持安全认证：AFNetworking支持HTTPS安全认证，可以保护应用程序中的敏感数据和通信内容。
支持数据解析和序列化：AFNetworking支持多种数据解析和序列化方式，包括JSON、XML、Property List等，可以方便地处理不同格式的数据。

阅读AFNetworking源码需要具备一定的Objective-C语言和iOS开发经验，以下是一个简单的阅读AFNetworking源码的思路：

了解AFNetworking的基本结构和类：AFNetworking由多个类组成，包括AFHTTPSessionManager、AFJSONResponseSerializer、AFURLRequestSerialization等，需要了解每个类的基本作用和功能。
理解网络请求和响应处理流程：AFNetworking支持多种网络请求和响应处理流程，需要了解每个流程的基本原理和实现方式。
了解AFNetworking的网络协议实现：AFNetworking支持多种网络协议，需要了解每种协议的基本实现原理和代码实现。
了解AFNetworking的缓存和离线模式实现：AFNetworking支持缓存和离线模式，需要了解缓存和离线模式的实现原理和代码实现。
学会阅读注释和文档：AFNetworking的源码中包含了大量的注释和文档，需要耐心地阅读，以便更好地理解源码的实现细节和设计思路。

SDWebImage是一个iOS图片加载和缓存库，它支持异步加载图片，可以从网络、本地文件和内存中加载图片，并提供了缓存机制，可以提高图片加载速度和应用程序的稳定性。SDWebImage采用Objective-C语言编写，支持iOS、macOS、watchOS和tvOS等平台。

SDWebImage的主要特点包括：

异步加载图片：SDWebImage支持异步加载图片，可以提高应用程序的响应速度和用户体验。
支持多种图片格式：SDWebImage支持多种图片格式，包括JPEG、PNG、GIF等，可以方便地处理不同格式的图片。
支持图片缓存：SDWebImage支持图片缓存，可以减少网络请求次数，提高应用程序的性能和稳定性。
支持图片压缩：SDWebImage支持图片压缩，可以减少图片大小，提高网络传输效率。
支持图片处理和动画：SDWebImage支持图片处理和动画，可以实现图片的剪裁、旋转、缩放等操作，同时支持图片的动画效果。

阅读SDWebImage源码需要具备一定的Objective-C语言和iOS开发经验，以下是一个简单的阅读SDWebImage源码的思路：

了解SDWebImage的基本结构和类：SDWebImage由多个类组成，包括SDWebImageManager、SDWebImageDownloader、SDImageCache等，需要了解每个类的基本作用和功能。
理解图片加载和缓存流程：SDWebImage支持图片加载和缓存，需要了解图片加载和缓存的基本原理和实现方式。
了解SDWebImage的网络协议实现：SDWebImage支持多种网络协议，需要了解每种协议的基本实现原理和代码实现。
了解SDWebImage的图片处理和动画实现：SDWebImage支持图片处理和动画，需要了解图片处理和动画的实现原理和代码实现。
学会阅读注释和文档：SDWebImage的源码中包含了大量的注释和文档，需要耐心地阅读，以便更好地理解源码的实现细节和设计思路。

21、两个链表找第一个相同结点

给定两个链表，找到它们的第一个相同结点。假设两个链表都不包含环。

一种简单的解决方法是利用哈希表，将第一个链表的结点全部存储到哈希表中，然后遍历第二个链表，查找第一个出现在哈希表中的结点，即为两个链表的第一个相同结点。这种方法的时间复杂度为O(m+n)，其中m和n分别为两个链表的长度，空间复杂度为O(m)。

另一种更优秀的解决方法是利用链表的性质，假设第一个链表的长度为L1，第二个链表的长度为L2，先分别遍历两个链表，得到它们的长度差d=L1-L2，然后将长链表的头指针向后移动d个结点，使得两个链表的长度相等。接着同时遍历两个链表，找到第一个相同的结点，即为它们的第一个相同结点。

这种方法的时间复杂度为O(m+n)，空间复杂度为O(1)，比哈希表方法更优秀。具体实现可以参考以下代码：

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    if (!headA || !headB) return NULL;
    int lenA = getLength(headA);
    int lenB = getLength(headB);
    ListNode *pA = headA, *pB = headB;
    while (lenA > lenB) {
        pA = pA->next;
        lenA--;
    }
    while (lenB > lenA) {
        pB = pB->next;
        lenB--;
    }
    while (pA && pB) {
        if (pA == pB) return pA;
        pA = pA->next;
        pB = pB->next;
    }
    return NULL;
}

int getLength(ListNode *head) {
    int len = 0;
    while (head) {
        len++;
        head = head->next;
    }
    return len;
}

其中getLength函数用于计算链表长度，getIntersectionNode函数用于查找第一个相同结点。

22、字符串旋转

字符串旋转是指将一个字符串中的字符按照一定的规律旋转后得到新的字符串。例如，字符串"abcdefg"旋转3个位置后，得到新的字符串"defgabc"。

一种简单的解决方法是使用字符串的拼接操作，将原字符串的后k个字符拼接到前面，得到新的字符串。例如，对于字符串"abcdefg"，如果要将其旋转3个位置，可以将"defg"拼接到"abc"前面，得到字符串"defgabc"。这种方法的时间复杂度为O(n)，其中n为字符串的长度，空间复杂度为O(n)。

另一种更优秀的解决方法是使用三次翻转操作。首先将原字符串分为两个部分，分别翻转这两个部分，得到翻转后的字符串。然后再将整个字符串翻转，得到最终的旋转后的字符串。例如，对于字符串"abcdefg"，如果要将其旋转3个位置，可以先将"abc"和"defg"分别翻转，得到"cbagfed"，然后再将整个字符串翻转，得到"defgabc"。这种方法的时间复杂度为O(n)，空间复杂度为O(1)。

以下是使用三次翻转操作的代码实现：

void reverseString(char *s, int left, int right) {
    while (left < right) {
        char temp = s[left];
        s[left] = s[right];
        s[right] = temp;
        left++;
        right--;
    }
}

void rotateString(char *s, int k) {
    int n = strlen(s);
    if (n < 2 || k == 0) return;
    k = k % n;
    reverseString(s, 0, n - k - 1);
    reverseString(s, n - k, n - 1);
    reverseString(s, 0, n - 1);
}

其中，reverseString函数用于翻转字符串中的一部分，rotateString函数用于旋转字符串。

23、找链表的倒数第k个结点

要找到链表的倒数第k个结点，可以使用双指针的方法，同时遍历链表，让一个指针先向前移动k个结点，然后两个指针同时向前移动，直到第一个指针到达链表末尾。此时，第二个指针指向的结点就是倒数第k个结点。

需要注意的是，如果链表长度小于k，则无法找到倒数第k个结点。另外，由于题目中要求返回倒数第k个结点的指针，因此需要特判k为1的情况，即返回链表的最后一个结点。

以下是使用双指针的代码实现：

ListNode* getKthFromEnd(ListNode* head, int k) {
    if (!head || k <= 0) return NULL;
    ListNode *p1 = head, *p2 = head;
    for (int i = 1; i < k; i++) {
        p1 = p1->next;
        if (!p1) return NULL; // 链表长度小于k
    }
    while (p1->next) {
        p1 = p1->next;
        p2 = p2->next;
    }
    return (k == 1) ? p1 : p2;
}

其中，p1指针先向前移动k个结点，p2指针指向链表头结点。然后两个指针同时向前移动，直到p1指针到达链表末尾。最后，如果k为1，则返回p1指针；否则返回p2指针。

24、把一个链表比某个值大的放在左边，比它小的放在右边

要将一个链表中比某个值大的结点放在左边，比它小的结点放在右边，可以使用分割链表的方法。具体来说，可以创建两个新的链表，分别用于存储比目标值小的结点和比目标值大的结点，然后遍历原链表，将小于等于目标值的结点插入到小链表中，将大于目标值的结点插入到大链表中。最后，将小链表和大链表合并成一个新的链表，即为所求。

以下是具体的代码实现：

ListNode* partition(ListNode* head, int x) {
    if (!head) return NULL;

    ListNode *smallHead = new ListNode(-1);
    ListNode *smallTail = smallHead;
    ListNode *largeHead = new ListNode(-1);
    ListNode *largeTail = largeHead;

    while (head) {
        if (head->val <= x) {
            smallTail->next = head;
            smallTail = smallTail->next;
        } else {
            largeTail->next = head;
            largeTail = largeTail->next;
        }
        head = head->next;
    }

    smallTail->next = largeHead->next;
    largeTail->next = NULL;
    ListNode *res = smallHead->next;

    delete smallHead;
    delete largeHead;

    return res;
}

其中，smallHead和smallTail分别指向小链表的头结点和尾结点，largeHead和largeTail分别指向大链表的头结点和尾结点。遍历原链表时，如果当前结点的值小于等于目标值，则将其插入到小链表中；否则将其插入到大链表中。最后，将小链表和大链表合并，并返回新链表的头结点。

需要注意的是，在返回新链表头结点之前，需要将原链表中的尾结点指向NULL，否则会产生环。另外，为了避免内存泄漏，需要在函数结束时释放申请的动态内存。

25、二叉树的中序遍历，非递归

二叉树的中序遍历可以使用非递归的方式实现，使用一个栈来辅助实现。具体的实现思路如下：

如果当前结点不为空，将其入栈，并将当前结点指向其左子树。
如果当前结点为空，说明已经到达最左侧结点，此时从栈中弹出一个结点，并输出其值，并将当前结点指向其右子树。
重复步骤1和步骤2，直到栈为空且当前结点为空为止。

以下是具体的代码实现：

vector<int> inorderTraversal(TreeNode* root) {
    vector<int> res;
    stack<TreeNode*> s;
    TreeNode *cur = root;
    while (cur || !s.empty()) {
        if (cur) {
            s.push(cur);
            cur = cur->left;
        } else {
            cur = s.top();
            s.pop();
            res.push_back(cur->val);
            cur = cur->right;
        }
    }
    return res;
}

其中，s为辅助栈，cur为当前结点。在循环中，如果当前结点不为空，则将其入栈，并将当前结点指向其左子树；如果当前结点为空，则从栈中弹出一个结点，并输出其值，然后将当前结点指向其右子树。重复执行这个过程，直到栈为空且当前结点为空为止。

最后返回一个vector，其中包含了中序遍历的结果序列。

腾讯-iOS面试题2面-答案

猜你喜欢