查找两个子视图的共同父视图

分析：可以反过来理解，两个子视图有共同父视图，那就说明共同父视图往下的父视图都相同，所以可以倒序来遍历，直到第一个不同的视图。

- (void)findCommonSuperViews:(UIView *)view1 view2:(UIView *)view2
{
    NSArray * superViews1 = [self findSuperViews:view1];
    NSArray * superViews2 = [self findSuperViews:view2];
    NSMutableArray * resultArray = [NSMutableArray array];
    int i = 0;

    while (i < MIN(superViews1.count, superViews2.count)) {
        UIView *super1 = superViews1[superViews1.count - i - 1];
        UIView *super2 = superViews2[superViews2.count - i - 1];
        if (super1 == super2) {
            [resultArray addObject:super1];
            i++;
        }else{
            break;
        }
    }
    NSLog(@"resultArray:%@",resultArray);
}
- (NSArray <UIView *>*)findSuperViews:(UIView *)view
{
    UIView * temp = view.superview;
    NSMutableArray * result = [NSMutableArray array];
    while (temp) {
        [result addObject:temp];
        temp = temp.superview;
    }
    return result;
}

链表逆序

原链表：4->3->2->1->NULL;
逆序后：1->2->3->4->NULL;

准备工作：定义链表结点结构，创建链表方法，打印链表方法

//链表结构体
struct Node{
      NSInteger data;
      struct Node *next;
}

/**
 新建一个链表,并返回头结点
 */
- (struct Node *)constructList{
    //头结点
    struct Node *head = NULL;
    //尾结点
    struct Node *end = NULL;
    
    for (int i = 0; i < 4; i++) {
        //malloc一个结点
        struct Node *node = malloc(sizeof(struct Node));
        
        node->data = i;
        node->next = NULL;
        //如果头结点为空，赋值头结点
        if (head == NULL) {
            head = node;
        }else{
            //如果头结点不为空，尾节点也就是当前结点next赋值为新结点
            end->next = node;
        }
        //尾节点赋值新结点
        end = node;
    }
    
    return head;
}

/**
 输出链表，参数是头结点
 */
- (void)printfList:(struct Node *)head{
    struct Node *temp = head;
    NSLog(@"list is : ");
    while (temp!=NULL) {
        NSLog(@"%ld",temp->data);
        temp = temp->next;
    }
}

链表逆序方法：

- (void)listReverse{
    struct Node * p = [self constructList];
    
    [self printfList:p];
    
    /*
     p: 0->1->2->3->4->5->6->7->8->9->null
     
     循环1：temp:1->2->3->4->5->6->7->8->9->null; p:0->null; newP:0->null; p:1->2->3->4->5->6->7->8->9->null;
     循环2：temp:2->3->4->5->6->7->8->9->null; p:1->0->null; newP:1->0->null; p:2->3->4->5->6->7->8->9->null;
                                   .
                                   .
                                   .
     循环9：temp:9->null; p:8->7->6->5->4->3->2->1->0->null; newP:8->7->6->5->4->3->2->1->0->null; p:9->null;
     循环10：temp:null; p:9->8->7->6->5->4->3->2->1->0->null; newP:9->8->7->6->5->4->3->2->1->0->null; p:null;
     */
    //逆序后的链表头部
    struct Node * newP = NULL;
    while (p!=NULL) {
        //记录下一个结点
        struct Node * temp = p->next;
        //当前结点的next指向新链表的头部
        p->next = newP;
        //更改新链表头部为当前结点
        newP = p;
        //移动p到下一个结点
        p = temp;
    }
    [self printfList:newP];
}

还有一种递归逆序的方式

- (struct Node *)diguiReverse:(struct Node *)head{
    if (!head || !head->next) {
        return head;
    }
    struct Node *newHead = [self diguiReverse:head->next];
    head->next->next = head;
    head->next = NULL;
    return newHead;
}

判断聊表是否循环

• 方式一，利用一个可变数组或者可变集合，遍历链表，如果可变数组中没有相同结点，将该结点放入可变数组中，继续遍历，直到尾部为NULL；如果可变数组中存在相同结点，则结束遍历，链表有循环。

/**
 判断链表是否循环

 @param head 链表
 @return 返回是否循环
 */
- (BOOL)listHasCycle:(struct Node *)head{
    NSMutableArray *mArr = [NSMutableArray array];
    while (head) {
        if ([mArr indexOfObject:(__bridge id _Nonnull)(head)]) {
            return YES;
        }
        [mArr addObject:(__bridge id _Nonnull)(head)];
        head = head->next;
    }
    return false;
}

• 方式二，快慢指针的运用，快指针指向next的next，慢指针指向next，如果如果快慢指针相等了，说明链表循环了。

/**
 判断链表是否循环，快慢指针的运用

 @param head 链表
 @return 返回是否循环
 */
- (BOOL)listHasCycle2:(struct Node *)head{
    struct Node * slow = head;
    struct Node * fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) {
            return YES;
        }
    }
    return NO;
}

字符串逆序

利用可变字符串的replace方法，只需遍历到一半就可以

/**
 字符串排序
 */
- (void)charReverse{
    NSString *string = @"hello world";
    NSMutableString *mStr = [NSMutableString stringWithString:string];
    
    for (int i = 0; i<string.length/2; i++) {
        [mStr replaceCharactersInRange:NSMakeRange(i, 1) withString:[string substringWithRange:NSMakeRange(string.length - 1 - i, 1)]];
        
        [mStr replaceCharactersInRange:NSMakeRange(string.length - 1 - i, 1) withString:[string substringWithRange:NSMakeRange(i, 1)]];
    }
    
    NSLog(@"%@",mStr);
}

有序数组的合并

分析：比较两个有序数组的下标的大小

- (void)orderListMerge{
    NSArray *array1 = @[@(2),@(6),@(10),@(12),@(13)];
    NSArray *array2 = @[@(1),@(3),@(7),@(8),@(11),@(16),@(18),@(20)];
    NSMutableArray *resultArr = [NSMutableArray array];
    int i = 0,j = 0;//i是array1的下标，j是array2的小标
    while (i<array1.count && j<array2.count) {
        if ([array1[i] integerValue] > [array2[j] integerValue]) {
            [resultArr addObject:array2[j]];
            j++;
        }else{
            [resultArr addObject:array1[i]];
            i++;
        }
    }
    
    while (i<array1.count) {
        [resultArr addObject:array1[i]];
        i++;
    }
    while (j<array2.count) {
        [resultArr addObject:array2[j++]];
    }
    NSLog(@"%@",resultArr);
}

冒泡排序

分析：两两比较相邻的数字

/**
 冒泡排序
两两比较相邻的对象

 @param array 可变数组
 */
- (void)maopaoPaixu:(NSMutableArray *)array{
    
    //flag 标识符，当在一个j循环中，没有交换位置，就说明序列已经有序的，当前i循环就直接退出
    BOOL flag = YES;
    for (int i = 0; i<array.count; i++) {
        flag = NO;
        //从尾部开始比较,将最大的放在头部
//        for (int j = array.count - 2; j>=i; j--) {
//            if ([array[j] intValue] < [array[j+1] intValue]) {
//                [array exchangeObjectAtIndex:j withObjectAtIndex:j+1];
//                flag = YES;
//            }
//        }
        //从头部开始比较,将最小的放在尾部
        for (int j = 0; j < array.count - 1 - i; j++) {
            if ([array[j] intValue] < [array[j+1] intValue]) {
                [array exchangeObjectAtIndex:j withObjectAtIndex:j+1];
                flag = YES;
            }
        }
        if (!flag) {
            break;
        }
    }
    NSLog(@"%@",array);
}

选择排序

分析：首先拿第一个数字跟后面所以数字依次比较，如果比第一个数大，则两两交换位置，直到遍历到末尾；
再拿第二个数跟后面所有数字一次比较，直到遍历到末尾；
再第三个数。。。一直到最后一位数。

/**
 选择排序,
 首先拿第一个数字跟后面所以数字依次比较，如果比第一个数大，则两两交换位置，直到遍历到末尾；
 再拿第二个数跟后面所有数字一次比较，直到遍历到末尾；
 再第三个数。。。一直到最后一位数。

 @param array 可变数组
 */
- (void)choosePaixu:(NSMutableArray *)array{
    BOOL flag = YES;
    for (int i = 0; i < array.count; i++) {
        flag = NO;
        for (int j = i+1; j < array.count; j++) {
            if ([array[i] intValue] < [array[j] intValue]) {
                [array exchangeObjectAtIndex:i withObjectAtIndex:j];
                flag = YES;
            }
        }
        if (!flag) {
            break;
        }
    }
}

有效的括号

给定一个只包括 ‘(‘，’)’，'{‘，’}’，'[‘，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

分析：利用栈先进后出的特点，当字符串遍历，遇到左括号就入栈，右括号就比较是否跟栈顶的括号成对（这里通过字典的key-value判断是否成对），不成对直接说明是无效的括号；遍历结束之后，判断栈是否是空栈，空栈则是有效括号，非空栈则是无效括号。

这里用OC中的可变数组代替一下栈。

- (BOOL)validateString: (NSString *)string{
    NSMutableString *mString = [NSMutableString stringWithString:string];
    //这里OC用数组代替一下栈
    NSMutableArray *mArr = [NSMutableArray array];
    NSDictionary *dic = @{@"(":@")",@"{":@"}",@"[":@"]"};
    for(int i=0;i<string.length;i++){
       NSString *sub = [mString subStringWithRange:NSRangeMake(i , 1)];
       if(dic[sub]){
          [mArr addObject:sub];
       }else{
          if(dic[[mArr lastObject]] != sub){
            return false;
          }
       }
    }
    return mArr.count == 0 ? true : false;
}

觉得有用，请帮忙点亮红心

Better Late Than Never!
努力是为了当机会来临时不会错失机会。
共勉！