OC面试题 十一、算法题

不使用中间变量交换两个变量

//加法
a = a + b;
b = a - b;
a = a - b;

//异或法
a = a^b;
b = a^b;
a = a^b;

关于异或的算法，简单说就是两数相同结果为0，两数不同结果为1。

• 任何数与0异或的结果为它本身。
• 两个相同的数异或的结果为0。

基于以上两点，上述的代码可以变形为：

a = a^b;
b = a^b = a^b^b = a^0 = a;
a = a^b = a^b^a = b^0 = b;

这样就和容易理解了，第一步a=a^b；的值没有意义，这是一个逻辑运算的值，这只是一个代换，用于后面两个语句进行逻辑运算。

冒泡排序

    int count = 0;
    int forcount = 0;
    NSMutableArray *arr = @[@16, @1, @2,@9,@7,@12,@5,@3,@8,@13,@10].mutableCopy;
    for (int i = 0; i < arr.count; i++) {
        forcount++;
        //依次定位左边的
        for (int j = (int)arr.count - 2; j >= i; j--) {
            count++;
            if ([arr[j] intValue] < [arr[j + 1] intValue]) {
                [arr exchangeObjectAtIndex:j withObjectAtIndex:j + 1];
            }
        }
        [self logArr:arr];
    }

寻找两个UIView的最近的公共父类

这个问的其实是数据结构中的 二叉树，查找一个普通二叉树中两个节点最近的公共祖先问题
假设两个视图为UIViewA、UIViewC，其中UIViewA继承于UIViewB，UIViewB继承于UIViewD，UIViewC也继承于UIViewD；即A->B->D，C->D
方法一：

- (void)viewDidLoad {
    [super viewDidLoad];
    Class commonClass1 = [self commonClass1:[ViewA class] andClass:[ViewC class]];
    NSLog(@"%@",commonClass1);
    // 输出：2018-03-22 17:36:01.868966+0800 两个UIView的最近公共父类[84288:2458900] ViewD
}
// 获取所有父类
- (NSArray *)superClasses:(Class)class {
    if (class == nil) {
        return @[];
    }
    NSMutableArray *result = [NSMutableArray array];
    while (class != nil) {
        [result addObject:class];
        class = [class superclass];
    }
    return [result copy];
}

- (Class)commonClass1:(Class)classA andClass:(Class)classB {
    NSArray *arr1 = [self superClasses:classA];
    NSArray *arr2 = [self superClasses:classB];
    for (NSUInteger i = 0; i < arr1.count; ++i) {
        Class targetClass = arr1[i];
        for (NSUInteger j = 0; j < arr2.count; ++j) {
            if (targetClass == arr2[j]) {
                return targetClass;
            }
        }
    }
    return nil;
}

方法一明显的是两层for循环，时间复杂度为O(N^2)

// 一个改进的办法:我们将一个路径中的所有点先放进NSSet中.因为NSSet的内部实现是一个hash表，所以查询元素的时间的复杂度变成O(1),我们一共有N个节点，所以总时间复杂度优化到了O(N)

- (Class)commonClass2:(Class)classA andClass:(Class)classB{
    NSArray *arr1 = [self superClasses:classA];
    NSArray *arr2 = [self superClasses:classB];
    NSSet *set = [NSSet setWithArray:arr2];
    for (NSUInteger i =0; i<arr1.count; ++i) {
        Class targetClass = arr1[i];
        if ([set containsObject:targetClass]) {
            return targetClass;
        }
    }
    return nil;
}

代码效果如下：

- (void)viewDidLoad {
    [super viewDidLoad];
    ///View1 View2
    Class commonClass = [self commonClass:[ViewA class] class:[ViewC class]];
    NSLog(@"%@",commonClass);
}

- (NSArray *)superClasses:(Class)class {
    if (class == nil) {
        return @[];
    }
    NSMutableArray *result = [NSMutableArray array];
    while (class != nil) {
        [result addObject:class];
        class = [class superclass];
    }
    return result.copy;
}

- (Class)commonClass:(Class)classA class:(Class)classB {
    NSArray *arr1 = [self superClasses:classA];
    NSArray *arr2 = [self superClasses:classB];
    NSSet *set = [NSSet setWithArray:arr2];
    for (int i = 0; i < arr1.count; i++) {
        Class targetClass = arr1[i];
        if ([set containsObject:targetClass]) {
            return targetClass;
        }
    }
    return  nil;
}

两数之和。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。

示例 1： 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2： 输入：nums = [3,2,4], target = 6 输出：[1,2]

示例 3： 输入：nums = [3,3], target = 6 输出：[0,1]

方法一：

使用暴力破解。时间复杂度O（n2）

public static int[] twoSum(int[]  nums, int target) {
    int i = 0, j = 0;
    for (i = 0;  i < nums.length; i++) {
        for (j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] == target) {
                return new int[] {i,j};
            }
        }
    }
    return null;
}

方法二：

使用 Hashtable 来存放已判断的数据，当下次查找 (target - num[i]) 时，发现有符合的条件，则查找成功，这样的话，时间复杂度就为 O（n）

public static int[]  twoSum(int[] nums, int target) {
    //建立k-v,一一对应的哈希表
    HashMap<Integer, Integer> hashtable = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        if (hashtable.containsKey(target - nums[i])) {
            return new int[] {i, hashtable.get(target - nums[i])};
        }
        hashtable.put(nums[i], i);
    }
    return null;
}