查找兩個(gè)子視圖的共同父視圖

分析：可以反過(guò)來(lái)理解，兩個(gè)子視圖有共同父視圖，那就說(shuō)明共同父視圖往下的父視圖都相同，所以可以倒序來(lái)遍歷，直到第一個(gè)不同的視圖。

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

準(zhǔn)備工作：定義鏈表結(jié)點(diǎn)結(jié)構(gòu)，創(chuàng)建鏈表方法，打印鏈表方法

//鏈表結(jié)構(gòu)體
struct Node{
      NSInteger data;
      struct Node *next;
}

/**
 新建一個(gè)鏈表,并返回頭結(jié)點(diǎn)
 */
- (struct Node *)constructList{
    //頭結(jié)點(diǎn)
    struct Node *head = NULL;
    //尾結(jié)點(diǎn)
    struct Node *end = NULL;
    
    for (int i = 0; i < 4; i++) {
        //malloc一個(gè)結(jié)點(diǎn)
        struct Node *node = malloc(sizeof(struct Node));
        
        node->data = i;
        node->next = NULL;
        //如果頭結(jié)點(diǎn)為空，賦值頭結(jié)點(diǎn)
        if (head == NULL) {
            head = node;
        }else{
            //如果頭結(jié)點(diǎn)不為空，尾節(jié)點(diǎn)也就是當(dāng)前結(jié)點(diǎn)next賦值為新結(jié)點(diǎn)
            end->next = node;
        }
        //尾節(jié)點(diǎn)賦值新結(jié)點(diǎn)
        end = node;
    }
    
    return head;
}

/**
 輸出鏈表，參數(shù)是頭結(jié)點(diǎn)
 */
- (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
     
     循環(huán)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;
     循環(huán)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;
                                   .
                                   .
                                   .
     循環(huán)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;
     循環(huán)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) {
        //記錄下一個(gè)結(jié)點(diǎn)
        struct Node * temp = p->next;
        //當(dāng)前結(jié)點(diǎn)的next指向新鏈表的頭部
        p->next = newP;
        //更改新鏈表頭部為當(dāng)前結(jié)點(diǎn)
        newP = p;
        //移動(dòng)p到下一個(gè)結(jié)點(diǎn)
        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;
}

判斷聊表是否循環(huán)

• 方式一，利用一個(gè)可變數(shù)組或者可變集合，遍歷鏈表，如果可變數(shù)組中沒(méi)有相同結(jié)點(diǎn)，將該結(jié)點(diǎn)放入可變數(shù)組中，繼續(xù)遍歷，直到尾部為NULL；如果可變數(shù)組中存在相同結(jié)點(diǎn)，則結(jié)束遍歷，鏈表有循環(huán)。

/**
 判斷鏈表是否循環(huán)

 @param head 鏈表
 @return 返回是否循環(huán)
 */
- (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;
}

• 方式二，快慢指針的運(yùn)用，快指針指向next的next，慢指針指向next，如果如果快慢指針相等了，說(shuō)明鏈表循環(huán)了。

/**
 判斷鏈表是否循環(huán)，快慢指針的運(yùn)用

 @param head 鏈表
 @return 返回是否循環(huán)
 */
- (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);
}

有序數(shù)組的合并

分析：比較兩個(gè)有序數(shù)組的下標(biāo)的大小

- (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的下標(biāo)，j是array2的小標(biāo)
    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);
}

冒泡排序

分析：兩兩比較相鄰的數(shù)字

/**
 冒泡排序
兩兩比較相鄰的對(duì)象

 @param array 可變數(shù)組
 */
- (void)maopaoPaixu:(NSMutableArray *)array{
    
    //flag 標(biāo)識(shí)符，當(dāng)在一個(gè)j循環(huán)中，沒(méi)有交換位置，就說(shuō)明序列已經(jīng)有序的，當(dāng)前i循環(huán)就直接退出
    BOOL flag = YES;
    for (int i = 0; i<array.count; i++) {
        flag = NO;
        //從尾部開(kāi)始比較,將最大的放在頭部
//        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;
//            }
//        }
        //從頭部開(kāi)始比較,將最小的放在尾部
        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);
}

選擇排序

分析：首先拿第一個(gè)數(shù)字跟后面所以數(shù)字依次比較，如果比第一個(gè)數(shù)大，則兩兩交換位置，直到遍歷到末尾；
再拿第二個(gè)數(shù)跟后面所有數(shù)字一次比較，直到遍歷到末尾；
再第三個(gè)數(shù)。。。一直到最后一位數(shù)。

/**
 選擇排序,
 首先拿第一個(gè)數(shù)字跟后面所以數(shù)字依次比較，如果比第一個(gè)數(shù)大，則兩兩交換位置，直到遍歷到末尾；
 再拿第二個(gè)數(shù)跟后面所有數(shù)字一次比較，直到遍歷到末尾；
 再第三個(gè)數(shù)。。。一直到最后一位數(shù)。

 @param array 可變數(shù)組
 */
- (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;
        }
    }
}

有效的括號(hào)

給定一個(gè)只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判斷字符串是否有效。

有效字符串需滿足：
左括號(hào)必須用相同類型的右括號(hào)閉合。
左括號(hào)必須以正確的順序閉合。
注意空字符串可被認(rèn)為是有效字符串。

分析：利用棧先進(jìn)后出的特點(diǎn)，當(dāng)字符串遍歷，遇到左括號(hào)就入棧，右括號(hào)就比較是否跟棧頂?shù)睦ㄌ?hào)成對(duì)（這里通過(guò)字典的key-value判斷是否成對(duì)），不成對(duì)直接說(shuō)明是無(wú)效的括號(hào)；遍歷結(jié)束之后，判斷棧是否是空棧，空棧則是有效括號(hào)，非空棧則是無(wú)效括號(hào)。

這里用OC中的可變數(shù)組代替一下棧。

- (BOOL)validateString: (NSString *)string{
    NSMutableString *mString = [NSMutableString stringWithString:string];
    //這里OC用數(shù)組代替一下棧
    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;
}

覺(jué)得有用，請(qǐng)幫忙點(diǎn)亮紅心

Better Late Than Never!
努力是為了當(dāng)機(jī)會(huì)來(lái)臨時(shí)不會(huì)錯(cuò)失機(jī)會(huì)。
共勉！