iOS面试的算法相关

• 面试中遇到的这些算法，在平常工作中，基本不会用到。

• 不过现实的面试中经常喜欢问关于算法的问题

• 有些还要求写出代码。一般来说，用c语言表达比较好。因为这是算法啊，过程式编程，当然是c语言比较合适。

• 在XCode中，Object-C和C可以混编，这个也算是蛮方便的

• Object-C推荐的命名方式是“小驼峰”，而C的经典应用场景是Linux，这里推荐的命名方式是小写字母加下划线连接

• 这里的Demo，将Object-C和C直接混编了。不过，在实际应用中，如果避不开C，那么还是将两者分开比较好。然后提供一个混编的接口层，进行隔离。不然，两种编程风格混合，对于代码的阅读和维护始终不是好事情。

Demo地址

快速排序

• 这是目前所知道的效率最高的排序算法，也是题解起来最抽象的一种排序算法，需要重点掌握。

• 挖坑填数+分治法下面这篇文章总结的很到位
  白话经典算法系列之六 快速排序 快速搞定

• 主要过程是：（s是数组，l是左边界，一般是0；r是右边界，数组长度-1）
  （1）将数组最左边的数s[l]取出来，暂存在一个临时变量x中
  （2）i =l; j = r; 将基准数挖出形成第一个坑s[i]。==== 挖坑
  （3）j--由后向前找比它小的数，找到后挖出此数填前一个坑s[i]中
  （4）i++由前向后找比它大的数，找到后也挖出此数填到前一个坑s[j]中。
  （5）重复执行2，3二步，直到i==j，将基准数，暂存在临时变量x中，填入s[i]中。
  （6）一遍走完了，然后左边来一下（l = l; r = i - 1）; 右边来一下（l = i + 1; r = r）=== 递归法，或者叫分治法
  （7）退出条件是l >= r;(只有一个元素了)

• 参考代码：

//快速排序  
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);
    }
}

冒泡排序

• 这是本人最喜欢的排序算法，因为简单

• 基本思想是找出最小的一个，放好；然后往前走一步，在剩下的里面找出最小的一个，放好；再往前走一步；===一直走到最后一步；

• 实现也简单，i，j两层循环嵌套就可以了。

void bubble_sort(int s[], int length) {
    for (int i = 0; i < length; i++) {
        for (int j = i; j < length; j++) {
            if (s[i] > s[j]) {
                int temp = s[i];
                s[i] = s[j];
                s[j] = temp;
            }
        }
    }
}

网上也有很好的参考文章。
经典排序算法 - 冒泡排序Bubble sort

求最大公约数

采用辗转相除法最简单。下面这篇文章写得很清楚
常见算法：C语言求最小公倍数和最大公约数三种算法

int gcd(int a, int b) {

    int temp = 0;

    if (a < b) {

        temp = a;

        a = b;

        b = temp;

    }

    while (b != 0) {

        temp = a % b;

        a = b;

        b = temp;

    }

    return a;
}

阶乘

这个实现很简单，就是递归的基本原理。还有著名的裴波那切数列，都是这一类问题。

（1）退出条件：参数为0或者1的时候，返回1
（2）递归：n * f(n-1)

如果要做好一点，就是判断一下参数，不要太大，否则程序会傻掉的（数值越界）

int factorial(int n) {
    if (n > 100) {
        return -1; // 太大了，算不出来，会越界
    }
    if (n == 1 || n ==0 ) {
        return 1;
    }
    return n * factorial(n - 1);
}

二分查找

• 先要将数组从小到大排好队

• 比较中间那个，找到就返回

• 根据比较结果，在左边找，或者在右边找

• 效率比遍历要高一些

• 返回的是数组下标

• 如果有重复的，找到一个就返回了，不一定是哪一个

int binary_search(int* a, int len, int goal) {
    int low = 0;
    int high = len - 1;
    while (low <= high) {
        int middle = (high - low) / 2 + low; // 直接使用(high + low) / 2 可能导致溢出
        if (a[middle] == goal) {
            return middle;
        }
        //在左半边
        else if (a[middle] > goal) {
            high = middle - 1;
        }
        //在右半边
        else {
            low = middle + 1;
        }
    }
    //没找到
    return -1;
}

判断质数

这里只用最简单直接打判断，一个个除，看余数

int isPrime(int n) {
    for(int i = 2; i <= sqrt(n); i++) {
        if(n % i == 0) {
            return 0;
        }
    }
    return 1;
}

更高效的算法，有相关的文章可以参考
判断一个数是否为质数/素数——从普通判断算法到高效判断算法思路

字符串逆序输出

直接用指针进行操作

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--;
    }
}

作者：老章888
链接：https://www.jianshu.com/p/c4820b159159
来源：
著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。