ios笔试题算法_iOS-面试题之算法(较全较易懂)

目录

常见算法

不用中间变量,用两种方法交换A和B的值

求最大公约数

判断质数

字符串逆序输出

排序相关算法

选择排序

冒泡排序

折半查找(二分查找)

快速排序

模拟栈的操作

序言

虽然我们在平时工作中，算法用的比较少，但是面试的时候，算法考核算是一个必修课。所以熟悉算法，深刻理解本质，对于面试就成竹在胸了。

一 常用算法

1.1 不用中间变量,用两种方法交换A和B的值

// 1.中间变量

void swap(int a, int b) {

int temp = a;

a = b;

b = temp;

}

// 2.加法

void swap(int a, int b) {

a = a + b;

b = a - b;

a = a - b;

}

// 3.异或(相同为0，不同为1. 可以理解为不进位加法)

void swap(int a, int b) {

a = a ^ b;

b = a ^ b;

a = a ^ b;

}

1.2 求最大公约数

比如20和4的最大公约数为4。18和27的最大公约数为9。

/** 1.直接遍历法 */

int maxCommonDivisor(int a, int b) {

int max = 0;

for (int i = 1; i <=b; i++) {

if (a % i == 0 && b % i == 0) {

max = i;

}

}

return max;

}

/** 2.辗转相除法 其中a为大数，b为小数 */

int maxCommonDivisor(int a, int b) {

int r;

while(a % b > 0) {

r = a % b;

a = b;

b = r;

}

return b;

}

1.3 判断质数

比如2,3,5,7,11,13,19等只能被1和自身整除的叫质数

这里只用最简单直接打判断，一个个除，看余数是否为零，如果不为零，则非质数。

int isPrime(int n) {

for(int i = 2; i <= sqrt(n); i++) {

if(n % i == 0) {

return 0;

}

}

return 1;

}

1.4 字符串逆序输出

直接用指针进行操作

void reverse(char s[]) {

// p指向字符串头部

char *p = s ;

// q指向字符串尾部

char *q = s ;

while('\0' != *q) {

q++ ;

}

q-- ;

// 交换并移动指针，直到p和q交叉

while(q > p) {

char t = *p;

char m = *q;

*p = m;

*q = t;

p++;

q--;

}

}

二 排序相关算法

2.1 选择排序

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小(大)元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

最值出现在起始端

第1趟：在n个数中找到最小(大)数与第一个数交换位置

第2趟：在剩下n-1个数中找到最小(大)数与第二个数交换位置

重复这样的操作...依次与第三个、第四个...数交换位置

第n-1趟，最终可实现数据的升序(降序)排列。

void selectSort(int *arr, int length) {

for (int i = 0; i < length - 1; i++) { //趟数

for (int j = i + 1; j < length; j++) { //比较次数

if (arr[i] > arr[j]) {

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

}

}

2.2 冒泡排序

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列)，就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

相邻元素两两比较，比较完一趟，最值出现在末尾

第1趟：依次比较相邻的两个数，不断交换(小数放前，大数放后)逐个推进，最值最后出现在第n个元素位置

第2趟：依次比较相邻的两个数，不断交换(小数放前，大数放后)逐个推进，最值最后出现在第n-1个元素位置

…… ……

第n-1趟：依次比较相邻的两个数，不断交换(小数放前，大数放后)逐个推进，最值最后出现在第2个元素位置

void bublleSort(int *arr, int length) {

for(int i = 0; i < length - 1; i++) { //趟数

for(int j = 0; j < length - i - 1; j++) { //比较次数

if(arr[j] > arr[j+1]) {

int temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

}

}

2.3 折半查找(二分查找)

在计算机科学中，折半搜索(英语：half-interval search)，也称二分搜索(英语：binary search)、对数搜索(英语：logarithmic search)，是一种在有序数组中查找某一特定元素的搜索算法。

搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半[1] 。

优化查找时间(不用遍历全部数据)

1 数组必须是有序的

2 必须已知min和max(知道范围)

3 动态计算mid的值，取出mid对应的值进行比较

4 如果mid对应的值大于要查找的值，那么max要变小为mid-1

5 如果mid对应的值小于要查找的值，那么min要变大为mid+1

已知一个有序数组, 和一个key, 要求从数组中找到key对应的索引位置

int findKey(int *arr, int length, int key) {

int min = 0, max = length - 1, mid;

while (min <= max) {

mid = (min + max) / 2; //计算中间值

if (key > arr[mid]) {

min = mid + 1;

} else if (key < arr[mid]) {

max = mid - 1;

} else {

return mid;

}

}

return -1;

}

2.4 快速排序

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

该方法的基本思想是：

1 先从数列中取出一个数作为基准数。

2 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3 再对左右区间重复第二步，直到各区间只有一个数。

** 一趟快速排序的算法是：**

1 设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2 以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3 从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]的值赋给A[i]；

4 从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]的值赋给A[j]；

5 重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束)。

或许很多人看了后还是很懵逼，有个哥们总结的很好

下面详细描述

虽然快速排序称为分治法，但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明：挖坑填数 + 分治法

以一个数组作为示例，取区间第一个数为基准数。

image.png

初始时，i = 0; j = 9; X = a[i] = 72

由于已经将a[0]中的数保存到X中，可以理解成在数组a[0]上挖了个坑，可以将其它数据填充到这来。

从j开始向前找一个比X小或等于X的数。当j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8]; i++; 这样一个坑a[0]就被搞定了，但又形成了一个新坑a[8]，这怎么办了？简单，再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数，当i=3，符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3]; j--;

数组变为：

image.png

i = 3; j = 7; X=72

再重复上面的步骤，先从后向前找，再从前向后找。

从j开始向前找，当j=5，符合条件，将a[5]挖出填到上一个坑中，a[3] = a[5]; i++;

从i开始向后找，当i=5时，由于i==j退出。

此时，i = j = 5，而a[5]刚好又是上次挖的坑，因此将X填入a[5]。

数组变为：

image.png

可以看出a[5]前面的数字都小于它，a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。

对挖坑填数进行总结

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。

2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。

3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。

4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

照着这个总结很容易实现挖坑填数的代码：

//快速排序

void quick_sort(int s[], int l, int r)

{

if (l < r)

{

//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1

int i = l, j = r, x = s[l];

while (i < j)

{

while(i < j && s[j] >= x) // 从右向左找第一个小于x的数

j--;

if(i < j)

s[i++] = s[j];

while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数

i++;

if(i < j)

s[j--] = s[i];

}

s[i] = x;

quick_sort(s, l, i - 1); // 递归调用

quick_sort(s, i + 1, r);

}

}

三 模拟栈的操作

栈是一种数据结构，特点：先进后出

代码实现

Stack.h

/**

定义block

@param obj 回调值

*/

typedef void(^StackBlock)(id obj);

/**

模拟栈实现 - 简单实现

*/

@interface Stack : NSObject

// 初始化操作

- (instancetype)initWithNumbers:(NSArray *)numbers;

/** 入栈 @param obj 指定入栈对象 */

- (void)push:(id)obj;

/** 出栈 */

- (id)popObj;

/** 是否为空 */

- (BOOL)isEmpty;

/** 栈的长度 */

- (NSInteger)stackLength;

/** 从栈底开始遍历 @param block 回调遍历的结果 */

-(void)enumerateObjectsFromBottom:(StackBlock)block;

/** 从顶部开始遍历 */

-(void)enumerateObjectsFromtop:(StackBlock)block;

/** 所有元素出栈，一边出栈一边返回元素 */

-(void)enumerateObjectsPopStack:(StackBlock)block;

/** 清空 */

-(void)removeAllObjects;

/** 返回栈顶元素 */

-(id)topObj;

@end

Stack.m

@interface Stack ()

// 存储栈数据

@property (nonatomic, strong) NSMutableArray *stackArray;

@end

@implementation Stack

// 初始化操作

- (instancetype)initWithNumbers:(NSArray *)numbers {

self = [super init];

if (self) {

for (NSNumber *number in numbers) {

[self.stackArray addObject:number];

}

}

return self;

}

#pragma mark - push

- (void)push:(id)obj {

[self.stackArray addObject:obj];

}

#pragma mark - get

- (id)popObj {

if ([self isEmpty]) {

return nil;

} else {

id lastObject = self.stackArray.lastObject;

[self.stackArray removeLastObject];

return lastObject;

}

}

-(id)topObj {

if ([self isEmpty]) {

return nil;

} else {

return self.stackArray.lastObject;

}

}

- (BOOL)isEmpty {

return !self.stackArray.count;

}

- (NSInteger)stackLength {

return self.stackArray.count;

}

#pragma mark - 遍历

// 从栈底开始遍历

-(void)enumerateObjectsFromBottom:(StackBlock)block {

[self.stackArray enumerateObjectsWithOptions:NSEnumerationConcurrent usingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {

block ? block(obj) : nil;

}];

}

// 从顶部开始遍历

-(void)enumerateObjectsFromtop:(StackBlock)block {

[self.stackArray enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {

block ? block(obj) : nil;

}];

}

// 所有元素出栈，一边出栈一边返回元素

-(void)enumerateObjectsPopStack:(StackBlock)block {

__weak typeof(self) weakSelf = self;

NSUInteger count = self.stackArray.count;

for (NSUInteger i = count; i > 0; i --) {

if (block) {

block(weakSelf.stackArray.lastObject);

[self.stackArray removeLastObject];

}

}

}

#pragma mark - remove

-(void)removeAllObjects {

[self.stackArray removeAllObjects];

}

#pragma mark - lazy

- (NSMutableArray *)stackArray {

if (!_stackArray) {

_stackArray = [NSMutableArray array];

}

return _stackArray;

}

@end