OC中双向链表的实现

双向链表的概念

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

双向链表的实现

链表的是由节点构成的，节点的创建代码如下：

@interface BOLoopListNode : NSObject
{
    BOLoopListNode *mpPrev;
    id mpData;
    BOLoopListNode *mpNext;
}
/**
 指向前一个数据
 */
@property (nonatomic, strong) BOLoopListNode *prev;

/**
 当前数据
 */
@property (nonatomic, strong) id data;

/**
 指向后一个数据
 */
@property (nonatomic, strong) BOLoopListNode *next;

+ (BOLoopListNode *)node;
+ (BOLoopListNode *)nodeWithData:(id)data;
- (id)initWithData:(id)data;

主要方法

1.链表的初始化方法

- (instancetype)init {
    if (self = [super init]) {
        mpHead = [[BOLoopListNode alloc] init];
        mpHead.prev = mpHead;
        mpHead.next = mpHead;
        mpCurrent = mpHead;
    }
    return self;
}

链表的初始化方法，此时已经形成了一个双向链表。该链表只有一个头结点，并且该节点的前驱和后继都指向自己。

2.拼接节点

- (BOLoopListNode *) appendNode:(BOLoopListNode *)pNode withPrevNode:(BOLoopListNode *) pPrevNode
{
    if (!pNode)
    {
        return nil;
    }
    pNode.prev = pPrevNode;
    pNode.next = pPrevNode.next;
    pPrevNode.next.prev = pNode;
    pPrevNode.next = pNode;
    muCount++;
    return pNode;
}

在pPrevNode处，插入pNode节点，并使当前链表的计数器加一。使pNode的前驱指向pPrevNode,使pNode的后继指向pPrevNode的next，并且使pPrevNode的next的前驱指向pNode。

3.移除节点

- (BOLoopListNode *) removeNode:(BOLoopListNode*) pNode
{
    if (!pNode)
    {
        pNode = mpCurrent;
    }
    if (pNode != mpHead)
    {
        pNode.prev.next = pNode.next;
        pNode.next.prev = pNode.prev;
        if (mpCurrent == pNode)
        {
            if (mpCurrent.next != mpHead)
            {
                mpCurrent = mpCurrent.next;
            }
            else
            {
                mpCurrent = mpCurrent.prev;
            }
            
        }
        muCount--;
        NSLog(@"%zd", muCount);
        return pNode;
    }
    else if(pNode == mpHead)
    {
        return nil;
    }
    return nil;
}

在判断要移除的节点非空并且不是头结点后，把pNode的prev的后继指向pNode的next，把pNode.next的前驱指向pNode的prev。并判断mpCurrent指针是否在该删除的节点上。

4.添加链表到目标链表

-(void)joinToListWithTargetList:(BOLoopList *)targetList withNode:(BOLoopListNode *)pNode {
    if (muCount == 0) {
        return;
    }else if (muCount == 1) {
        [targetList appendNode:[self getBegin] withPrevNode:pNode];
        muCount = 0;
    }else {
        pNode.next.prev = mpHead.prev;
        mpHead.prev.next = pNode.next;
        pNode.next = mpHead.next;
        mpHead.next.prev = pNode;
        mpHead.next = mpHead;
        mpHead.prev = mpHead;
        targetList.listCount += muCount;
        muCount = 0;
    }
}

判断要添加的链表长度，如果为一，当成一个节点拼接进去，若是不是一，就把该链表拼接到目标链表的尾端。

5.排序函数

// 升序排列
- (void)sortByAscendingOrder {
    if (muCount < 2)
    {
        //空链表与一个节点的链表无需排序
        return;
    }
    //记录下开始节点
    BOLoopListNode* pBeginNode = mpHead.next.next;
    BOLoopListNode* pEndNode = mpHead.prev;
    BOLoopListNode* pCurrentNode = pBeginNode;
    //取下链表中第一个节点之外的节点
    mpHead.next.next = mpHead;
    mpHead.next.prev = mpHead;
    mpHead.prev = mpHead.next;
    //使取下节点中的开始节点的前一节点与结束节点的后一节点指向nil
    pBeginNode.prev = nil;
    pEndNode.next = nil;
    BOLoopListNode* pEnumNode = nil;
    BOLoopListNode* pAddNode = nil;
    kNodeCompare compareResult = kNodeCompareLessThan;
    
    while (pCurrentNode)
    {
        pAddNode = pCurrentNode;
        pCurrentNode = pCurrentNode.next;
        for (pEnumNode = mpHead.prev; pEnumNode != mpHead; pEnumNode = pEnumNode.prev)
        {
            //当前链表从大到小(降序)遍历
        
            compareResult = (kNodeCompare)[self.delegate nodeCompare:(pAddNode.data) withSecondData:pEnumNode.data];;
            if (compareResult != kNodeCompareLessThan)
            {
                //要添加的节点不小于当前链表中枚举节点
                //将要添加的节点加到枚举节点后面
                pAddNode.next = pEnumNode.next;
                pAddNode.next.prev = pAddNode;
                pAddNode.prev = pEnumNode;
                pEnumNode.next = pAddNode;
                break;
            }
        }
        //要添加的节点比链表中所有的节点都小
        //加到头结点的后面
        if (pEnumNode == mpHead)
        {
            pAddNode.next = mpHead.next;
            mpHead.next.prev = pAddNode;
            pAddNode.prev = mpHead;
            mpHead.next = pAddNode;
        }
    }
}

这里以升序排序为例，在这里为什么取链表中第一个节点之外的节点。相当于在第二个节点之前截断，第一个节点用作比较，此时从某种意义上说，自头指针那儿分割，已经变成了两个链表。每次取head指针左边的和右边的比较，在合适的节点处插入。

而代码：

compareResult = (kNodeCompare)[self.delegate nodeCompare:(pAddNode.data) withSecondData:pEnumNode.data];

因为链表中的数据类型是不确定的，所以比较方法也是不确定的。则是外界成为了我的代理，传进来的比较链表中数据的方法。

协议代码如下：

typedef enum
{
    kNodeCompareLessThan = -1,
    kNodeCompareEqual,
    kNodeCompareMoreThan
}kNodeCompare;

@protocol kNodeCompareDelegate <NSObject>
- (kNodeCompare) nodeCompare:(id)firsrData withSecondData:(id)secondData;

降序排序跟这个类似，就不多说了。

详细代码BOLoopListNode类如下：

#import <Foundation/Foundation.h>

@interface BOLoopListNode : NSObject
{
    BOLoopListNode *mpPrev;
    id mpData;
    BOLoopListNode *mpNext;
}
/**
 指向前一个数据
 */
@property (nonatomic, strong) BOLoopListNode *prev;

/**
 当前数据
 */
@property (nonatomic, strong) id data;

/**
 指向后一个数据
 */
@property (nonatomic, strong) BOLoopListNode *next;

+ (BOLoopListNode *)node;
+ (BOLoopListNode *)nodeWithData:(id)data;
- (id)initWithData:(id)data;
@end

#import "BOLoopListNode.h"

@implementation BOLoopListNode

- (void)dealloc {
    self.data = nil;
    self.prev = nil;
    self.next = nil;
}
- (instancetype)init {
    return [self initWithData:nil];
}
- (instancetype)initWithData:(id)data {
    if (self = [super init]) {
        self.prev = nil;
        self.data = data;
        self.next = nil;
    }
    return self;
}

+ (BOLoopListNode *)node {
    BOLoopListNode *node = [[BOLoopListNode alloc] init];
    return node;
}

+ (BOLoopListNode *)nodeWithData:(id)data {
    BOLoopListNode *node = [[BOLoopListNode alloc] initWithData:data];
    return node;
}
@end

BOLoopList类代码如下：

#import <Foundation/Foundation.h>
#import "BOLoopListNode.h"

typedef enum
{
    kNodeCompareLessThan = -1,
    kNodeCompareEqual,
    kNodeCompareMoreThan
}kNodeCompare;

@protocol kNodeCompareDelegate <NSObject>
- (kNodeCompare) nodeCompare:(id)firsrData withSecondData:(id)secondData;
@end;

@interface BOLoopList : NSObject
{
    BOLoopListNode *mpHead;
    BOLoopListNode *mpCurrent;
    NSUInteger muCount;
}
@property (nonatomic, weak) id<kNodeCompareDelegate> delegate;
/**头指针*/
@property (nonatomic, strong) BOLoopListNode *head;

/**开始的指针*/
@property (nonatomic, strong) BOLoopListNode *begin;

/**末尾指针*/
@property (nonatomic, strong) BOLoopListNode *end;

/**当前的指针*/
@property (nonatomic, strong) BOLoopListNode *current;

/**当前链表数据个数*/
@property (nonatomic, assign) NSUInteger listCount;

+ (id)list;

/**得到头部指针*/
- (BOLoopListNode *)getHead;

/**得到开始数据的指针*/
- (BOLoopListNode *)getBegin;

/**得到末尾数据*/
- (BOLoopListNode *)getEnd;

/**移动当前数据指针到开始*/
- (BOLoopListNode *)moveBegin;

/**移动当前数据指针到末尾*/
- (BOLoopListNode *)moveEnd;

/**移动到头指针*/
- (BOLoopListNode *)moveHead;

/**移动当前数据指针到下一个*/
- (BOLoopListNode*) moveNext;

/**移动当前指针到上一个*/
- (BOLoopListNode*) movePrev;

/**拼接数据*/
- (BOLoopListNode *)appendData:(id)data;

/**在某一节点处拼接数据*/
- (BOLoopListNode *)appendData:(id)data withPrevNode:(BOLoopListNode *)prevNode;

/**拼接节点*/
- (BOLoopListNode *)appendNode:(BOLoopListNode *)pNode;

/**在某个节点处拼接节点*/
- (BOLoopListNode *)appendNode:(BOLoopListNode *)pNode withPrevNode:(BOLoopListNode *)pNode;

/**删除某个数据对应的节点*/
- (BOLoopListNode *)removeNodeWithData:(id)data;

/**删除某个节点*/
- (BOLoopListNode *)removeNode:(BOLoopListNode *)pNode;

/**添加一个链表到另外一个链表*/
- (void)joinToListWithTargetList:(BOLoopList *)targetList withNode:(BOLoopListNode *)pNode;

/**升序排列链表*/
- (void) sortByAscendingOrder;

/**按降序排序*/
- (void) sortByDeScendingOrder;

/**在某个节点后面拼接一个节点*/
- (BOLoopListNode*) preAppendNode:(BOLoopListNode*) pNode withNextNode:(BOLoopListNode*) pNextNode;

/**清空链表*/
- (void)clearList;
@end

#import "BOLoopList.h"
@interface BOLoopList()

@end
@implementation BOLoopList
@synthesize listCount = muCount;

- (instancetype)init {
    if (self = [super init]) {
        mpHead = [[BOLoopListNode alloc] init];
        mpHead.prev = mpHead;
        mpHead.next = mpHead;
        mpCurrent = mpHead;
    }
    return self;
}
+ (id)list {
    return [[self alloc] init];
}

- (BOLoopListNode *)getHead {
    return mpHead;
}

- (BOLoopListNode *)getBegin {
    return mpHead.next;
}

- (BOLoopListNode *)getEnd {
    return mpHead.prev;
}

- (BOLoopListNode *) moveBegin
{
    return mpCurrent = mpHead.next;
}

- (BOLoopListNode *) moveEnd
{
    return mpCurrent = mpHead.prev;
}

- (BOLoopListNode *) moveHead
{
    return mpCurrent = mpHead;
}

- (BOLoopListNode *) moveNext
{
    return mpCurrent = mpCurrent.next;
}

- (BOLoopListNode *) movePrev
{
    return mpCurrent = mpCurrent.prev;
}

- (BOLoopListNode *) appendData:(id) data
{
    return [self appendData:data withPrevNode:mpHead.prev];
}

- (BOLoopListNode *) appendData:(NSString *)data withPrevNode:(BOLoopListNode *) pPrevNode
{
    NSLog(@"liupeng%@",data);
    BOLoopListNode* pNode = [BOLoopListNode nodeWithData:data];
    return [self appendNode:pNode withPrevNode:pPrevNode];
}

- (BOLoopListNode *) appendNode:(BOLoopListNode *) pNode
{
    return [self appendNode:pNode withPrevNode:mpHead.prev];
}

- (BOLoopListNode *) appendNode:(BOLoopListNode *)pNode withPrevNode:(BOLoopListNode *) pPrevNode
{
    if (!pNode)
    {
        return nil;
    }
    pNode.prev = pPrevNode;
    pNode.next = pPrevNode.next;
    pPrevNode.next.prev = pNode;
    pPrevNode.next = pNode;
    muCount++;
    return pNode;
}
- (BOLoopListNode*) removeNodeWithData:(id) data
{
    for (BOLoopListNode* pNode = mpHead.next; pNode != mpHead; pNode = pNode.next)
    {
        if (pNode.data == data)
        {
            return [self removeNode:pNode];
        }
    }
    return nil;
}

- (BOLoopListNode *) removeNode:(BOLoopListNode*) pNode
{
    if (!pNode)
    {
        pNode = mpCurrent;
    }
    if (pNode != mpHead)
    {
        pNode.prev.next = pNode.next;
        pNode.next.prev = pNode.prev;
        if (mpCurrent == pNode)
        {
            if (mpCurrent.next != mpHead)
            {
                mpCurrent = mpCurrent.next;
            }
            else
            {
                mpCurrent = mpCurrent.prev;
            }
            
        }
        muCount--;
        NSLog(@"%zd", muCount);
        return pNode;
    }
    else if(pNode == mpHead)
    {
        return nil;
    }
    return nil;
}
-(void)joinToListWithTargetList:(BOLoopList *)targetList withNode:(BOLoopListNode *)pNode {
    if (muCount == 0) {
        return;
    }else if (muCount == 1) {
        [targetList appendNode:[self getBegin] withPrevNode:pNode];
        muCount = 0;
    }else {
        pNode.next.prev = mpHead.prev;
        mpHead.prev.next = pNode.next;
        pNode.next = mpHead.next;
        mpHead.next.prev = pNode;
        mpHead.next = mpHead;
        mpHead.prev = mpHead;
        targetList.listCount += muCount;
        muCount = 0;
    }
}
- (void) clearList
{
    mpCurrent = mpHead.next;
    while (muCount)
    {
        mpCurrent = mpCurrent.next;
        muCount--;
    }
    mpCurrent = mpHead;
    mpHead.prev = mpHead;
    mpHead.next = mpHead;
   
    return;
}
// 升序排列
- (void)sortByAscendingOrder {
    if (muCount < 2)
    {
        //空链表与一个节点的链表无需排序
        return;
    }
    //记录下开始节点
    BOLoopListNode* pBeginNode = mpHead.next.next;
    BOLoopListNode* pEndNode = mpHead.prev;
    BOLoopListNode* pCurrentNode = pBeginNode;
    //取下链表中第一个节点之外的节点
    mpHead.next.next = mpHead;
    mpHead.next.prev = mpHead;
    mpHead.prev = mpHead.next;
    //使取下节点中的开始节点的前一节点与结束节点的后一节点指向nil
    pBeginNode.prev = nil;
    pEndNode.next = nil;
    BOLoopListNode* pEnumNode = nil;
    BOLoopListNode* pAddNode = nil;
    kNodeCompare compareResult = kNodeCompareLessThan;
    
    while (pCurrentNode)
    {
        pAddNode = pCurrentNode;
        pCurrentNode = pCurrentNode.next;
        for (pEnumNode = mpHead.prev; pEnumNode != mpHead; pEnumNode = pEnumNode.prev)
        {
            //当前链表从大到小(降序)遍历
        
            compareResult = (kNodeCompare)[self.delegate nodeCompare:(pAddNode.data) withSecondData:pEnumNode.data];
            if (compareResult != kNodeCompareLessThan)
            {
                //要添加的节点不小于当前链表中枚举节点
                //将要添加的节点加到枚举节点后面
                pAddNode.next = pEnumNode.next;
                pAddNode.next.prev = pAddNode;
                pAddNode.prev = pEnumNode;
                pEnumNode.next = pAddNode;
                break;
            }
        }
        //要添加的节点比链表中所有的节点都小
        //加到头结点的后面
        if (pEnumNode == mpHead)
        {
            pAddNode.next = mpHead.next;
            mpHead.next.prev = pAddNode;
            pAddNode.prev = mpHead;
            mpHead.next = pAddNode;
        }
    }
}

// 降序排列
- (void)sortByDeScendingOrder {
    if (muCount < 2)
    {
        //空链表与一个节点的链表无需排序
        return;
    }
    //记录下开始节点
    BOLoopListNode* pBeginNode = mpHead.next.next;
    BOLoopListNode* pEndNode = mpHead.prev;
    BOLoopListNode* pCurrentNode = pBeginNode;
    //取下链表中第一个节点之外的节点
    mpHead.next.next = mpHead;
    mpHead.next.prev = mpHead;
    mpHead.prev = mpHead.next;
    //使取下节点中的开始节点的前一节点与结束节点的后一节点指向nil
    pBeginNode.prev = nil;
    pEndNode.next = nil;
    BOLoopListNode* pEnumNode = nil;
    BOLoopListNode* pAddNode = nil;
    kNodeCompare compareResult = kNodeCompareLessThan;
    
    while (pCurrentNode)
    {
        pAddNode = pCurrentNode;
        pCurrentNode = pCurrentNode.next;
        for (pEnumNode = mpHead.next; pEnumNode != mpHead; pEnumNode = pEnumNode.next)
        {
            //当前链表从大到小(降序)遍历
            compareResult = (kNodeCompare)[self.delegate nodeCompare:(pAddNode.data) withSecondData:pEnumNode.data];
            if (compareResult != kNodeCompareLessThan)
            {
                //要添加的节点不小于当前链表中枚举节点
                //将要添加的节点加到枚举节点前面
                pAddNode.prev = pEnumNode.prev;
                pAddNode.prev.next = pAddNode;
                pAddNode.next = pEnumNode;
                pEnumNode.prev = pAddNode;
                break;
                
            }
        }
        //要添加的节点比链表中所有的节点都小
        //加到头结点的前面
        if (pEnumNode == mpHead)
        {
            pAddNode.prev = mpHead.prev;
            pAddNode.prev.next = pAddNode;
            pAddNode.next = mpHead;
            mpHead.prev = pAddNode;
        }
    }

}

- (BOLoopListNode*) preAppendNode:(BOLoopListNode*) pNode withNextNode:(BOLoopListNode*) pNextNode
{
    if (!pNode)
    {
        return nil;
    }
    pNode.prev = pNextNode.prev;
    pNode.next = pNextNode;
    pNextNode.prev.next = pNode;
    pNextNode.prev = pNode;
    muCount++;
    return pNode;
}
@end