OC实现排序

快速排序

数字数组测试

NSArray* sortArray = @[@4, @7, @6, @3, @8, @2, @9, @1, @5];

NSArray* rsArray = [self quickSort:sortArray sorctCallBack:^BOOL(id obj1, id obj2) {

    /// yes 降序, no 升序 自定义对象大小 
    return [obj1 integerValue] > [obj2 integerValue];
}];
NSLog(@"--------- %@",rsArray);

实现代码

-(NSArray*)quickSort:(NSArray*)sortArray sorctCallBack:(BOOL(^)(id obj1, id obj2))sortCallBack{

   if (!sortArray || ![sortArray isKindOfClass:[NSArray class]] || sortArray.count == 0) {
     return sortArray;
   }
   return [self __quickSort:sortArray.mutableCopy startIndex:0 endIndex:[sortArray count] - 1 sorctCallBack:sortCallBack];
}

-(NSArray*)__quickSort:(NSMutableArray*)sortArray
    startIndex:(NSInteger)startIndex
    endIndex:(NSInteger)endIndex
    sorctCallBack:(BOOL(^)(id obj1, id obj2))sortCallBack{

    if (startIndex >= endIndex) {
        return sortArray;
    }
    NSInteger start = startIndex;
    NSInteger end = endIndex;
    id standardObj = sortArray[start];


    while (end > start){

        while (end > start && sortCallBack(standardObj, sortArray[end]) == YES) {
            end = end - 1;
        }
        sortArray[start] = sortArray[end];

        while (end > start && sortCallBack(standardObj, sortArray[start]) == NO){
            start = start + 1;
        }
        sortArray[end] = sortArray[start];
    }

    sortArray[start] = standardObj;

    [self __quickSort:sortArray startIndex:startIndex endIndex:start - 1 sorctCallBack:sortCallBack];
    [self __quickSort:sortArray startIndex:start + 1 endIndex:endIndex sorctCallBack:sortCallBack];

    return sortArray;
}

二叉树

节点model

@interface BSNode : NSObject

@property(nonatomic,strong)BSNode* leftNode;
@property(nonatomic,strong)BSNode* rightNode;

@property(nonatomic,strong)id key;

@end

添加节点

NSLog(@"----添加");
NSArray* testArray = @[@5,@3,@1,@2,@4,@6,@7,@8,@9];
BSNode* node = [self insertNode:testArray];

#pragma mark - 增加节点
-(BSNode*)insertNode:(NSArray*)nodeArray{

    __strong BSNode* node = NULL;
    for (int i = 0; i < nodeArray.count; i++) {
        node = [self _insertNode:node key:[nodeArray objectAtIndex:i]];
    }
    return node;
}
-(BSNode*)_insertNode:(BSNode*)node key:(id)key{

    if (!node) {
        node = [[BSNode alloc] init];
        node.key = key;
        node.leftNode = nil;
        node.rightNode = nil;
        return node;
    }
    if ([key integerValue] < [node.key integerValue]) {
        node.leftNode = [self _insertNode:node.leftNode key:key];
    }else{
        node.rightNode = [self _insertNode:node.rightNode key:key];
    }
    return node;
}

遍历节点(升序输出)

#pragma mark - 遍历节点
-(void)searchNodes:(BSNode*)node{

    if (node) {

        [self searchNodes:node.leftNode];
        
        NSLog(@"searchNodes---- %@",node.key);
        [self searchNodes:node.rightNode];
    }
}

查询节点

#pragma mark - 查询节点
-(id)selectNode:(BSNode*)node key:(id)key{

    if (!node) {
        return nil;
    }
    if ([key integerValue] == [node.key integerValue]) {
        return node;
    }
    if ([key integerValue] > [node.key integerValue]) {

        return [self selectNode:node.rightNode key:key];
    }
    return [self selectNode:node.leftNode key:key];
}

获取最大/最小

#pragma mark - 最小/大节点
-(id)selectMaxOrMinNode:(BSNode*)node isMax:(BOOL)isMax{

    BSNode* tNode = isMax == YES ? node.rightNode : node.leftNode;
    BSNode* rs = tNode;
    while (tNode != nil) {
        rs = tNode;
        tNode = isMax == YES ? tNode.rightNode : tNode.leftNode;
    }
    return rs;
}