文档章节

iOS-数据结构之链表以及二叉树

麦兜卖鱼丸
 麦兜卖鱼丸
发布于 2016/11/07 15:02
字数 2384
阅读 148
收藏 0

(一)前言

对于频繁使用或者是操作的数据应当使用链表,提升效率;

(1)链表的优点:链表插入和删除节点付出的代价较小,主要的操作在于prev或next指针的重指向。缺点:链表不能通过下标或者是key查询某个节点,要想获取某一指定的节点,需要从_headNode从头开始遍历,消耗是极大的。

(2)数组、字典等数据结构,相对于链表而言,遍历的效率要好得多,也可以通过下标或key获取指定的元素,这个恰好是链表的缺点;而数组、字典等,在添加或删除元素之后,会从头到尾重新的排列所有的元素,消耗极大;

因此,结合两者的优点,下面所要介绍的双向链表内容,会使用dictionary保存所有的节点信息,以便通过key能获取到指定的节点,用于链表的操作;

(3)二叉树,大多数操作都采用递归思想,比如添加节点、前序遍历、中序遍历、后序遍历以及计算节点数等;(递归调用是通过栈来实现的,每调用一次函数,系统都将函数当前的变量、返回地址等信息保存为一个栈帧压入到栈中,那么一旦要处理的运算很大或者数据很多,有可能会导致很多函数调用或者很大的栈帧,这样不断的压栈,很容易导致栈的溢出);

 

(二)双向链表;

(1)双向链表节点类,包含key、value以及前节点和后节点等信息;

#import <Foundation/Foundation.h>

@interface NTLinkedNode : NSObject

@property (nonatomic, strong) NSString *key;
@property (nonatomic, strong) NSString *value;
@property (nonatomic, strong) NTLinkedNode *prev;
@property (nonatomic, strong) NTLinkedNode *next;

@end



 

(2)双向链表管理类,可以添加、移动、删除节点;

#import <Foundation/Foundation.h>
@class NTLinkedNode;

@interface NTLinkedMap : NSObject

- (void)addNodeAtHead:(NTLinkedNode *)node;
- (void)addNode:(NTLinkedNode *)newNode beforeNodeForKey:(NSString *)key;
- (void)addNode:(NTLinkedNode *)newNode behindNodeForKey:(NSString *)key;
- (void)bringNodeToHead:(NTLinkedNode *)node;

- (void)readAllNode;
- (void)removeNodeForKey:(NSString *)key;
- (NTLinkedNode *)removeTailNode;

- (void)headNode;
- (void)tailNode;

@end



#import "NTLinkedMap.h"
#import "NTLinkedNode.h"

@interface NTLinkedMap () {
    
    NTLinkedNode *_headNode;//头节点;
    NTLinkedNode *_tailNode;//尾节点;
    NSMutableDictionary *dicKeyValue;//用于保存所有节点;
}

@end

@implementation NTLinkedMap

- (instancetype)init {
    
    self = [super init];
    if (self) {
        
        dicKeyValue = [NSMutableDictionary dictionary];
    }
    
    return self;
}

//将节点添加在头部之前;
- (void)addNodeAtHead:(NTLinkedNode *)node {
    
    dicKeyValue[node.key] = node;
    if (_headNode) {
        
        node.next = _headNode;
        _headNode.prev = node;
        _headNode = node;
        
    } else {
        
        _headNode = _tailNode = node;
    }
}

//在指定的节点之前添加新节点;
- (void)addNode:(NTLinkedNode *)newNode beforeNodeForKey:(NSString *)key {
    
    NTLinkedNode *node = dicKeyValue[key];
    dicKeyValue[newNode.key] = newNode;
    
    if (!_headNode && !_tailNode) {
        
        _headNode = _tailNode = newNode;
    }
    
    if (node) {
        
        if ([_headNode isEqual:node]) {
            
            _headNode = newNode;
        }
        
        if (node.prev) {
            
            newNode.prev = node.prev;
            node.prev.next = newNode;
        }
        
        newNode.next = node;
        node.prev = newNode;
    }
}


//在指定的节点之后添加新节点;
- (void)addNode:(NTLinkedNode *)newNode behindNodeForKey:(NSString *)key {
    
    NTLinkedNode *node = dicKeyValue[key];
    dicKeyValue[newNode.key] = newNode;
    
    if (!_headNode && !_tailNode) {
        
        _headNode = _tailNode = newNode;
        
    } else {
        
        if (node) {
            
            if ([_tailNode isEqual:node]) {
                
                _tailNode = newNode;
            }
            
            if (node.next) {
                
                node.next.prev = newNode;
                newNode.next = node.next;
            }
            
            newNode.prev = node;
            node.next = newNode;
        }
    }
}


//移动node至头部节点;
- (void)bringNodeToHead:(NTLinkedNode *)node {
    
    if ([_headNode isEqual:node]) {
        
        return;
    }
    
    if ([_tailNode isEqual:node]) {
        
        _tailNode = node.prev;
        _tailNode.next = nil;
        
    } else {
        
        node.next.prev = node.prev;
        node.prev.next = node.next;
    }
    
    _headNode.prev = node;
    node.next = _headNode;
    node.prev = nil;
    _headNode = node;
}


//移除某个节点;
- (void)removeNodeForKey:(NSString *)key {
    
    NTLinkedNode *node = dicKeyValue[key];
    if (node) {
        
        [dicKeyValue removeObjectForKey:key];
        if (node.next) {
            
            node.next.prev = node.prev;
        }
        
        if (node.prev) {
            
            node.prev.next = node.next;
        }
        
        if ([_headNode isEqual:node]) {
            
            _headNode = node.next;
        }
        
        if ([_tailNode isEqual:node]) {
            
            _tailNode = node.prev;
        }
    }
}


//移除尾部节点;
- (NTLinkedNode *)removeTailNode {
    
    if (!_tailNode) {
        
        return nil;
    }
    
    NTLinkedNode *tailNode = _tailNode;
    [dicKeyValue removeObjectForKey:_tailNode.key];
    if (_headNode == _tailNode) {
        
        _headNode = _tailNode = nil;
        
    } else {
        
        _tailNode = _tailNode.prev;
        _tailNode.next = nil;
    }
    
    return tailNode;
}


//遍历所有的node节点;
- (void)readAllNode {
    
    if (_headNode) {
        
        NTLinkedNode *node = _headNode;
        while (node) {
            
            NSLog(@"key -- %@, value -- %@", node.key, node.value);
            node = node.next;
        }
    }
}

- (void)headNode {
    
    NSLog(@"head node key -- %@, head node value -- %@", _headNode.key, _headNode.value);
    NSLog(@"node count -- %lu", (unsigned long)dicKeyValue.count);
}

- (void)tailNode {
    
    NSLog(@"tail node key -- %@, tail node value -- %@", _tailNode.key, _tailNode.value);
    NSLog(@"node count -- %lu", (unsigned long)dicKeyValue.count);
}
@end

 

(三)单向链表;

(1)单向链表节点类,保存节点信息;

#import <Foundation/Foundation.h>

@interface NTSingleLinkedNode : NSObject

@property (nonatomic, strong) NSString *key;
@property (nonatomic, strong) NSString *value;
@property (nonatomic, strong) NTSingleLinkedNode *next;

@end

 

(2)单向链表管理类,用于添加、删除、移动以及遍历链表节点;

#import <Foundation/Foundation.h>
@class NTSingleLinkedNode;

@interface NTSingleLinkedList : NSObject

- (void)addNodeAtHead:(NTSingleLinkedNode *)node;
- (NTSingleLinkedNode *)addNode:(NTSingleLinkedNode *)newNode behindNodeForKey:(NSString *)key;

- (NTSingleLinkedNode *)removeNode:(NTSingleLinkedNode *)node;
- (NTSingleLinkedNode *)selectNode:(NSString *)key;
- (void)bringNodeToHead:(NTSingleLinkedNode *)node;

- (void)readAllNode;

@end


#import "NTSingleLinkedList.h"
#import "NTSingleLinkedNode.h"

@interface NTSingleLinkedList () {
    
    NTSingleLinkedNode *_headNode;
    NSMutableDictionary *dictKeyValue;
}

@end

@implementation NTSingleLinkedList

- (instancetype)init {
    
    self = [super init];
    if (self) {
        
        dictKeyValue = [NSMutableDictionary dictionary];
    }
    
    return self;
}

//新节点添加在头部之前;
- (void)addNodeAtHead:(NTSingleLinkedNode *)node {
    
    dictKeyValue[node.key] = node;
    if (_headNode) {
        
        node.next = _headNode;
        _headNode = node;
        
    } else {
        
        _headNode = node;
    }
}


//新节点添加值指定节点之后(节点不可重复);
- (NTSingleLinkedNode *)addNode:(NTSingleLinkedNode *)newNode behindNodeForKey:(NSString *)key {
    
    if (!key) {
        
        return _headNode;
    }
    
    NTSingleLinkedNode *node = dictKeyValue[key];
    if (dictKeyValue[newNode.key]) {//判断节点是否存在;
        
        return _headNode;
    }
    
    dictKeyValue[newNode.key] = newNode;
    newNode.next = node.next;
    node.next = newNode;
    
    
    return newNode;
}


//删除节点;
- (NTSingleLinkedNode *)removeNode:(NTSingleLinkedNode *)node {
    
    if (!_headNode || !node) {
        
        return _headNode;
    }
    
    NTSingleLinkedNode *tempNode;
    [dictKeyValue removeObjectForKey:node.key];
    
    //若删除节点不是尾节点,则将当前节点替换成当前节点的下一个节点;
    if (node.next) {
        
        tempNode = node.next;
        node.next = node.next.next;
        node.key = tempNode.key;
        node.value = tempNode.value;
        
        tempNode = nil;
        return _headNode;
        
    } else {
        
        //从_headNode开始遍历链表,找到tempNode即node的前一个节点;
        tempNode = _headNode;
        while (tempNode.next && ![tempNode.next isEqual:node]) {
            
            tempNode = tempNode.next;
        }
        
        if (tempNode.next) {
            
            tempNode.next = node.next;
        }
    }
    
    return _headNode;
}


//将node移至头部head;
- (void)bringNodeToHead:(NTSingleLinkedNode *)node {
    
    if (!_headNode || !node) {
        
        return;
    }
    
    if ([_headNode isEqual:node]) {
        
        return ;
    }
    
    //从_headNode开始遍历链表,找到tempNode即node的前一个节点;
    NTSingleLinkedNode *tempNode = _headNode;
    while (tempNode.next && ![tempNode.next isEqual:node]) {
        
        tempNode = tempNode.next;
    }
    
    if (tempNode.next) {
        
        tempNode.next = node.next;
    }
    
    node.next = _headNode;
    _headNode = node;
}


//查找单向列表中的一个节点;
- (NTSingleLinkedNode *)selectNode:(NSString *)key {
    
    //当然了,因为定义了字典dicKeyVaue,可以通过此字典,直接返回对应key的node;
    //return dicKeyVaue[key];
    
    NTSingleLinkedNode *tempNode = _headNode;
    while (tempNode) {
        
        if ([tempNode.key isEqualToString:key]) {
            
            return tempNode;
        }
        
        tempNode = tempNode.next;
    }
    
    return _headNode;
}


//遍历所有节点;
- (void)readAllNode {
    
    NTSingleLinkedNode *tempNode = _headNode;
    while (tempNode) {
        
        NSLog(@"node key -- %@, node value -- %@", tempNode.key, tempNode.value);
        tempNode = tempNode.next;
    }
}
@end

 

(四)二叉树(二叉排序树),参考来自网络收集资料

(1)二叉树节点定义,包含左节点leftNode、右节点rightNode、父节点(未使用)以及节点值value;

#import <Foundation/Foundation.h>

@interface NTBinaryTreeNode : NSObject

@property (nonatomic, assign) NSInteger value;

/**
 *  父节点
 */
@property (nonatomic, strong) NTBinaryTreeNode *fatherNode;

/**
 *  左节点
 */
@property (nonatomic, strong) NTBinaryTreeNode *leftNode;
/**
 *  右节点
 */
@property (nonatomic, strong) NTBinaryTreeNode *rightNode;

@end

 

(2)二叉树管理类,创建和遍历二叉树以及增加二叉树节点等;

#import <Foundation/Foundation.h>
@class NTBinaryTreeNode;

@interface NTBinaryTree : NSObject

+ (NTBinaryTreeNode *)createTreeWithValues:(NSArray *)values;
+ (NTBinaryTreeNode *)addTreeNode:(NTBinaryTreeNode *)treeNode value:(NSInteger)value;

+ (NTBinaryTreeNode *)invertBinaryTree:(NTBinaryTreeNode *)rootNode;

+ (NTBinaryTreeNode *)treeNodeAtIndex:(NSInteger)index inTree:(NTBinaryTreeNode *)treeNode;

+ (void)levelTraverseTree:(NTBinaryTreeNode *)treeNode handler:(void (^)(NTBinaryTreeNode *node))handler;
+ (void)depthTraverseTree:(NTBinaryTreeNode *)treeNode handler:(void (^)(NTBinaryTreeNode *node))handler;

+ (void)preOrderTraverseTree:(NTBinaryTreeNode *)rootNode handler:(void(^)(NTBinaryTreeNode *treeNode))handler;

//非递归遍历二叉树;
+ (void)preTraverseTree:(NTBinaryTreeNode *)treeNode handler:(void (^)(NTBinaryTreeNode *node))handler;
+ (void)inTraverseTree:(NTBinaryTreeNode *)treeNode handler:(void (^)(NTBinaryTreeNode *node))handler;
+ (void)postTraverseTree:(NTBinaryTreeNode *)treeNode handler:(void (^)(NTBinaryTreeNode *node))handler;

@end



#import "NTBinaryTree.h"
#import "NTBinaryTreeNode.h"

@implementation NTBinaryTree


/**
 *  创建二叉排序树
 *  二叉排序树:左节点值全部小于根节点值,右节点值全部大于根节点值
 *
 *  @param values 数组
 *
 *  @return 二叉树根节点
 */
+ (NTBinaryTreeNode *)createTreeWithValues:(NSArray *)values {
    
    NTBinaryTreeNode *root = nil;
    for (NSInteger i = 0; i < values.count; i++) {
        
        NSInteger value = [(NSNumber *)[values objectAtIndex:i] integerValue];
        root = [NTBinaryTree addTreeNode:root value:value];
    }
    
    return root;
}


//递归添加节点,始终返回根节点;
+ (NTBinaryTreeNode *)addTreeNode:(NTBinaryTreeNode *)treeNode value:(NSInteger)value {
    
    //根节点不存在,创建节点
    if (!treeNode) {
        
        treeNode = [NTBinaryTreeNode new];
        treeNode.value = value;
        //NSLog(@"node:%@", @(value));
        
    } else if (value <= treeNode.value) {
        
        NSLog(@"to left");
        //值小于根节点,则插入到左子树
        treeNode.leftNode = [NTBinaryTree addTreeNode:treeNode.leftNode value:value];
        
    } else {
        
        NSLog(@"to right");
        //值大于根节点,则插入到右子树
        treeNode.rightNode = [NTBinaryTree addTreeNode:treeNode.rightNode value:value];
    }
    
    return treeNode;
}


//反转二叉树(左右节点互换),递归思想;
+ (NTBinaryTreeNode *)invertBinaryTree:(NTBinaryTreeNode *)rootNode {
    
    if (!rootNode) {
        
        return nil;
    }
    
    if (!rootNode.leftNode && !rootNode.rightNode) {
        
        return rootNode;
    }
    
    [self invertBinaryTree:rootNode.leftNode];//递归反转左节点;
    [self invertBinaryTree:rootNode.rightNode];//递归反转右节点;
    NTBinaryTreeNode *tempNode = rootNode.leftNode;
    rootNode.leftNode = rootNode.rightNode;
    rootNode.rightNode = tempNode;
    
    
    return rootNode;
}

//查找index位置的node -- 从0开始查找,根据先进先出的顺序查找;
+ (NTBinaryTreeNode *)treeNodeAtIndex:(NSInteger)index inTree:(NTBinaryTreeNode *)treeNode {
    
    if (!treeNode || index < 0) {
        
        return nil;
    }
    
    NSMutableArray *queryArray = [NSMutableArray array];
    [queryArray addObject:treeNode];
    
    while (queryArray.count > 0) {
        
        NTBinaryTreeNode *node = [queryArray firstObject];
        
        if (index == 0) {
            
            return node;
        }
        
        [queryArray removeObjectAtIndex:0];
        index--;
        
        if (node.leftNode) {
            
            [queryArray addObject:node.leftNode];
        }
        
        if (node.rightNode) {
            
            [queryArray addObject:node.rightNode];
        }
    }
    
    return nil;
}


//广度优先遍历二叉树,从上到下,从左到右依次遍历,先遍历完一层再遍历下一层;
+ (void)levelTraverseTree:(NTBinaryTreeNode *)treeNode handler:(void (^)(NTBinaryTreeNode *))handler {
    
    if (!treeNode) {
        
        return;
    }
    
    NSMutableArray *queryArray = [NSMutableArray array];
    [queryArray addObject:treeNode];
    
    while (queryArray.count > 0) {
        
        NTBinaryTreeNode *node = [queryArray firstObject];
        
        if (handler) {
            
            handler(node);
        }
        
        [queryArray removeObjectAtIndex:0];//仿照队列fifo原则;
        
        if (node.leftNode) {
            
            [queryArray addObject:node.leftNode];
        }
        
        if (node.rightNode) {
            
            [queryArray addObject:node.rightNode];
        }
    }
}


//深度优先遍历,先遍历左子树,再遍历右子树;
+ (void)depthTraverseTree:(NTBinaryTreeNode *)treeNode handler:(void (^)(NTBinaryTreeNode *))handler {
    
    if (!treeNode) {
        
        return;
    }
    
    NSMutableArray *queryArray = [NSMutableArray array];
    [queryArray addObject:treeNode];
    
    while (queryArray.count > 0) {
        
        NTBinaryTreeNode *node = [queryArray firstObject];
        
        if (handler) {
            
            handler(node);
        }
        
        [queryArray removeObjectAtIndex:0];//仿照队列fifo原则;
        
        if (node.rightNode) {
            
            [queryArray addObject:node.rightNode];
        }
        
        if (node.leftNode) {
            
            [queryArray addObject:node.leftNode];
        }
    }
}


/**
 *  前序遍历 (中序遍历 -- 先左子树,再根,再右子树;后序遍历 -- 先左子树,再右子树,再根。)
 *  先访问根,再遍历左子树,再遍历右子树;递归思想,每一个不为空的节点都重复先访问根,再遍历左子树,再遍历右子树的流程;
 *
 *  @param rootNode 根节点
 *  @param handler  访问节点处理函数
 */
+ (void)preOrderTraverseTree:(NTBinaryTreeNode *)rootNode handler:(void(^)(NTBinaryTreeNode *treeNode))handler {
    
    if (rootNode) {
        
        //读取节点信息;
        if (handler) {
            
            handler(rootNode);
        }
        
        [self preOrderTraverseTree:rootNode.leftNode handler:handler];
        [self preOrderTraverseTree:rootNode.rightNode handler:handler];
    }
}


//非递归 -- 模拟节点进出栈方法实现,前序遍历;
+ (void)preTraverseTree:(NTBinaryTreeNode *)treeNode handler:(void (^)(NTBinaryTreeNode *))handler {
    
    if (!treeNode) {
        
        return;
    }
    
    NSMutableArray *queryArray = [NSMutableArray array];
    NTBinaryTreeNode *node = treeNode;
    
    while (node || queryArray.count > 0) {
        
        while (node) {
            
            //读取节点信息;
            if (handler) {
                
                handler(node);
            }
            
            [queryArray addObject:node];
            node = node.leftNode;
        }
        
        if (queryArray.count > 0) {
            
            node = [queryArray lastObject];
            [queryArray removeObject:node];
            node = node.rightNode;
        }
    }
}


//非递归 -- 模拟节点进出栈方法实现,中序遍历;
+ (void)inTraverseTree:(NTBinaryTreeNode *)treeNode handler:(void (^)(NTBinaryTreeNode *))handler {
    
    if (!treeNode) {
        
        return;
    }
    
    NTBinaryTreeNode *node = treeNode;
    NSMutableArray *queryArray = [NSMutableArray array];
    
    while (node || queryArray.count > 0) {
        
        while (node) {
            
            [queryArray addObject:node];
            node = node.leftNode;
        }
        
        if (queryArray.count > 0) {
            
            node = [queryArray lastObject];
            [queryArray removeObject:node];
            
            //读取节点信息;
            if (handler) {
                
                handler(node);
            }
            
            node = node.rightNode;
        }
    }
}


//非递归 -- 模拟节点进出栈方法实现,后序遍历;
+ (void)postTraverseTree:(NTBinaryTreeNode *)treeNode handler:(void (^)(NTBinaryTreeNode *))handler {
    
    if (!treeNode) {
        
        return;
    }
    
    NTBinaryTreeNode *preNode = nil;
    NTBinaryTreeNode *curNode;
    NSMutableArray *queryArray = [NSMutableArray array];
    [queryArray addObject:treeNode];
    
    while (queryArray.count > 0) {
        
        //(1)当前节点左右孩子都不存在,可以直接访问该节点;
        //(2)存在左孩子节点或者是右孩子节点,且其左右孩子节点已经被访问过,也可以直接访问该节点;
        curNode = [queryArray lastObject];
        if ((!curNode.leftNode && !curNode.rightNode) || (preNode && ([preNode isEqual:curNode.leftNode] || [preNode isEqual:curNode.rightNode]))) {
            
            if (handler) {
                
                handler(curNode);
            }
            
            [queryArray removeObject:curNode];
            preNode = curNode;
            
        }  else {
            
            if (curNode.rightNode) {
                
                [queryArray addObject:curNode.rightNode];
            }
            
            if (curNode.leftNode) {
                
                [queryArray addObject:curNode.leftNode];
            }
        }
    }
}
@end

 

© 著作权归作者所有

上一篇: iOS-单元测试
下一篇: iOS-Masonry
麦兜卖鱼丸
粉丝 12
博文 69
码字总数 69333
作品 0
桂林
iOS工程师
私信 提问
加载中

评论(2)

麦兜卖鱼丸
麦兜卖鱼丸 博主

引用来自“小码爱大牛”的评论

你好,我是深圳一家以家居安防为核心的智能家居公司的HR在招聘一位iOS开发架构师兼leader。不知道您自己或者身边同事朋友有没有在看工作机会的呢?如果感兴趣可以发简历到3288771685@qq.com或者加QQ。
不好意思,我现在不在深圳。
小码爱大牛
小码爱大牛
你好,我是深圳一家以家居安防为核心的智能家居公司的HR在招聘一位iOS开发架构师兼leader。不知道您自己或者身边同事朋友有没有在看工作机会的呢?如果感兴趣可以发简历到3288771685@qq.com或者加QQ。
应用性能接入框架 - Matrix for iOS/macOS

Matrix for iOS/macOS 是一款微信团队研发并日常使用的性能探针工具,目前集成在 iOS 和 macOS 微信的 APM(Application Performance Manage)平台中使用。Matrix for iOS/macOS 建立了一套 ...

匿名
04/04
2.7K
1
求教!!求教!!求教!!!

#if !defined(AFX_NODELIST_H__9781C411_82DF_47F7_A449_3054B18A550E__INCLUDED_) #define AFX_NODELIST_H__9781C411_82DF_47F7_A449_3054B18A550E__INCLUDED_ #if _MSC_VER > 1000 #pragma......

phoenix33
2014/03/28
128
1
2018 iOS 面试题大全(补充完整版)

原文地址:2018 iOS 面试题大全 由于原作者并没有继续更新,这里我转过来继续更新下 这个栏目将持续更新--请iOS的小伙伴关注! 1、iOS 应用导航模式有哪些? 2、iOS 中持久化方式有哪些? 3、...

Theendisthebegi
2018/11/15
0
0
2019 iOS面试题总结(题目及答案已上传Githup)

Objective_C语言特性 一、分类 二、扩展 三、代理(Delegate) 四、通知(NSNotification) 五、KVO (Key-value observing) 六、KVC(Key-value coding) 七、属性关键字 runloop 一、RunLoop...

iOS开发_小迷糊
06/24
0
0
【AR】开始使用Vuforia开发iOS(2)

原 设置iOS开发环境 安装Vuforia iOS SDK 如何安装Vuforia iOS示例 编译并运行Vuforia iOS示例 支持iOS金属 iOS 64位迁移 设置iOS开发环境 适用于iOS的Vuforia引擎目前支持运行iOS 9及更高版...

lichong951
2018/06/11
0
0

没有更多内容

加载失败,请刷新页面

加载更多

500行代码,教你用python写个微信飞机大战

这几天在重温微信小游戏的飞机大战,玩着玩着就在思考人生了,这飞机大战怎么就可以做的那么好,操作简单,简单上手。 帮助蹲厕族、YP族、饭圈女孩在无聊之余可以有一样东西让他们振作起来!...

上海小胖
今天
8
0
关于AsyncTask的onPostExcute方法是否会在Activity重建过程中调用的问题

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 本文链接:https://blog.csdn.net/XG1057415595/article/details/86774575 假设下面一种情况...

shzwork
今天
7
0
object 类中有哪些方法?

getClass(): 获取运行时类的对象 equals():判断其他对象是否与此对象相等 hashcode():返回该对象的哈希码值 toString():返回该对象的字符串表示 clone(): 创建并返此对象的一个副本 wait...

happywe
今天
6
0
Docker容器实战(七) - 容器中进程视野下的文件系统

前两文中,讲了Linux容器最基础的两种技术 Namespace 作用是“隔离”,它让应用进程只能看到该Namespace内的“世界” Cgroups 作用是“限制”,它给这个“世界”围上了一圈看不见的墙 这么一...

JavaEdge
今天
8
0
文件访问和共享的方法介绍

在上一篇文章中,你了解到文件有三个不同的权限集。拥有该文件的用户有一个集合,拥有该文件的组的成员有一个集合,然后最终一个集合适用于其他所有人。在长列表(ls -l)中这些权限使用符号...

老孟的Linux私房菜
今天
7
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部