线性表之单向链表的基本操作实现

线性表之单向链表的基本操作实现

---

这篇文章用来回顾单向链表的相关知识并实现如下几个操作:

• 初始化
• 插入
• 删除
• 逆置
• 销毁

且实现的链表为带头节点的单线非循环链表.由于链表在尾插入时需要遍历到链表的最后一个位置,所以我需要记住最后一个节点的位置,为此,本文会简单的实现一个单向链表的类.

---

0.链表的定义与类中提供的API

typedef int ELEMENT;

struct Node_s {
    Node_s():data(),NEXT(nullptr){}
    ELEMENT data;
    Node_s * NEXT;
};

typedef Node_s Node;
typedef Node * NodePtr;

class CForward_List
{
public:
    CForward_List(void);

    ~CForward_List(void);

    // 当空时返回真
    bool isEmpty();

    // 从文件中读入节点数据
    size_t readFromFile(std::string &_filename);

    // 在头节点后插入一个节点
    void insert_atHead(ELEMENT &_data);

    // 在尾节点后插入一个节点
    void insert_atTail(ELEMENT &_data);

    // 在指定位置后插入一个节点
    void insert_before(ELEMENT &_positionData,ELEMENT &_insertData);

    // 删除链表中指定元素的值 
    void deleteNode_single(ELEMENT &_data);

    // 销毁链表中的所有数据
    void deleteAllData();

    // 更新链表中的值
    NodePtr update(ELEMENT &_originalData,ELEMENT &_data);

    // 搜索链表中的值的位置
    NodePtr search(ELEMENT &_data);

    // 将链表逆置
    NodePtr reverse();

    // Sort by bubble/insert/select
    NodePtr sort(SORTWAY _sortway);

    // Show
    void showListInfo();

private:
    // 节点数量
    size_t size;
    
    // 头节点
    NodePtr listHeadPtr;
    
    // 尾节点
    NodePtr listEndPtr;

    // 在一个指定位置后插入一个节点
    void insert_after(NodePtr insertPos,ELEMENT &_data);
    
    // 删除指定节点后的节点
    void deleteNode_specific(NodePtr beforeDeleteNode);
    
    // 下一个是否与当前的相等
    bool nextEqualThis(NodePtr nodePos,ELEMENT &_data);

    // 冒泡排序
    NodePtr sort_bubble();
    void sort_swap(ELEMENT * _data1,ELEMENT *_data2);

    // 选择排序
    NodePtr sort_select();
    NodePtr sort_select_min(NodePtr _startNode);

    // 插入排序
    NodePtr sort_insert();
    NodePtr findInsertPos(NodePtr _newListHeadPtr,NodePtr _seekedNode);
    void sort_insert_after(NodePtr _firstNode,NodePtr _secondNode);
};

 下面会分步的实现前面提到的函数.

1.初始化(构造)与析构函数

　　初始化函数先创建一个头结点,将链表的大小置为0,指向尾部的节点为空;

CForward_List::CForward_List(void):listHeadPtr(nullptr),listEndPtr(nullptr)
{
    size = 0;
    listHeadPtr 　　= new Node;
    listEndPtr    　= nullptr;
}

　　析构函数为了确保所有节点都被清理会调用销毁相关的函数,在deleteAllData()函数内部会处理size的值.

CForward_List::~CForward_List(void)
{
    // 删除所有节点信息
    deleteAllData();

    if(!listHeadPtr)
        delete listHeadPtr;
    if (!listEndPtr)
        delete listEndPtr;
}

2.插入操作

头插入:

　　其实头插入就是在头指针后插入一个节点,这里体会到了使用头结点的方便性.

void CForward_List::insert_atHead(ELEMENT &_data){
    insert_after(listHeadPtr,_data);
}

尾插入:

　　其实为插入也就是在尾指针后进行插入一个节点的行为,但是这里需要判断链表是否为空,

　　因为,若链表为空的话尾指针指向的对象是空的,所以需要在头结点后插入,然后将尾指针指向插入的元素即可.

　　否则,直接在尾指针后插入即可.

void CForward_List::insert_atTail(ELEMENT &_data){
    if (isEmpty())
        insert_after(listHeadPtr,_data);
    else
        insert_after(listEndPtr,_data);
}

在指定位置之前插入:

　　对链表进行指定元素的插入操作最重要的就是,要找到指定元素的前驱节点.然后再调用前面的 insert_after 函数即可.

void CForward_List::insert_before(ELEMENT &_positionData,ELEMENT &_insertData){
    NodePtr node = listHeadPtr;
    while (node){
        if (nextEqualThis(node,_positionData)){
            insert_after(node,_insertData);
            break;
        }
        node = node->NEXT;
    }
}

nextEqualThis函数是判断传入节点node与node->next的data值是否相等,相等返回true,否则返回false;

插入操作的总结:

　　其实插入操作就是一个遍历的过程,要找到插入位置之前的节点是关键;

　　这里对两个功能进行模块化,一是在指定节点后的插入行为,二是判断当前节点是否与下一个节点相等.

具体的插入操作:

void CForward_List::insert_after(NodePtr _insertPos,ELEMENT &_data){
    NodePtr insertNode  = new Node;
    insertNode->data    = _data;
    // 判断是否要移动尾指针的位置
    if (!_insertPos->NEXT)
        listEndPtr = insertNode;
    // 进行插入操作
    insertNode->NEXT    = _insertPos->NEXT;
    _insertPos->NEXT    = insertNode;
    size++;
}

bool CForward_List::nextEqualThis(NodePtr _nodePos,ELEMENT &_data){
    if (!_nodePos->NEXT)
        return false;
    else
        return _nodePos->NEXT->data == _data;
}

　　这里的代码和许多教科书上的代码都不尽相同,因为我想着什么是插入操作的共同点,然后将其提取出来,将代码量减少.

但是上面有一个问题就是在指定位置插入的过程中,遍历查找的操作会频繁调用nextEqualThis函数,要论如何优化的话我想要是设置为inline可能会是一个不错的选择,但是编译其听不听我的话就是另一回事了:)

3.删除操作

　　删除操作和前面的在指定位置插入有许多相同之处.,也是遍历以查找到删除之前的那个节点,然后在那个位置上执行删除操作.

void CForward_List::deleteNode_single(ELEMENT &_data){
    NodePtr node = listHeadPtr;
    while (node){
        if (nextEqualThis(node,_data)){
            deleteNode_specific(node);
            break;
        }
        node = node->NEXT;
    }
}

具体的删除操作:

void CForward_List::deleteNode_specific(NodePtr _beforeDeleteNode){
    NodePtr deletedNode = _beforeDeleteNode->NEXT;
    _beforeDeleteNode->NEXT = deletedNode->NEXT;
    // 若删除的节点是尾节点,则需要重新设置尾节点
    if (!deletedNode->NEXT)
        listEndPtr = _beforeDeleteNode;
    size--;
    delete deletedNode;
}

删除操作的总结:

　　可以发现删除操作的思路和插入的大致相同,遍历是前提.但是在删除的具体操作中,需要判断是否删除的是尾指针.

4.逆置操作

　　逆置的思路就是遍历的过程中把当前这个节点指向前面的节点. 10 - 19 行才是关键,只是在遍历的过程中需要几个临时变量记住即将发生变化的节点.

NodePtr CForward_List::reverse(){
    NodePtr 
        head     = listHeadPtr->NEXT,
        tmpPtr   = nullptr,
        preNode  = nullptr;

    // Record the end_pointer
    listEndPtr = head;

    while (head){
        // Record the next node,beacuse I will change the next value
        tmpPtr= head->NEXT;
        // Reverse operation
        head->NEXT = preNode;
        // Record current node
        preNode = head;
        // Require the next node.
        head = tmpPtr;
    }
    // Make the head_pointer point to the reversed list.
    listHeadPtr ->NEXT = preNode;

    return listHeadPtr;
}

5.排序操作

　　这里实现了三种排序方式,根据参数的不同做出不同的反映.可惜的是他们的平均时间复杂度都是O(n^2)

NodePtr CForward_List::sort(SORTWAY _sortway){
    if(_sortway == BUBBLESORT)
        listHeadPtr = sort_bubble();
    else if (_sortway == SELECTSORT)
        listHeadPtr = sort_select();
    else if (_sortway == INSERTSORT)
        listHeadPtr = sort_insert();
    return listHeadPtr;
}

冒泡排序:

　　按照从大到小排序.

NodePtr CForward_List::sort_bubble(){
    for (NodePtr kNode = listHeadPtr->NEXT;kNode;kNode = kNode->NEXT)
        for (NodePtr fNode = listHeadPtr->NEXT;fNode;fNode=fNode->NEXT)
            if (kNode->data > fNode->data)
                sort_swap(&kNode->data,&fNode->data);
    return listHeadPtr;
}

选择排序:

　　按照从小到大排序.遍历到的每个元素都是最小的元素.

NodePtr CForward_List::sort_select(){
    for (NodePtr kNode = listHeadPtr->NEXT;kNode;kNode = kNode->NEXT){
        NodePtr minNodePtr = sort_select_min(kNode);
        sort_swap(&kNode->data,&minNodePtr->data);
    }
    return listHeadPtr;
}

选择最小元素的具体过程;这里有一个细节,就是为什么不在sort_select_min函数传入kNode->NEXT,因为避免返回值是nullptr.导致sort_swap异常.

NodePtr CForward_List::sort_select_min(NodePtr _startNode){
    ELEMENT minData = _startNode->data;
    NodePtr minPtr    = _startNode;
    for (NodePtr fNode = _startNode->NEXT;fNode;fNode=fNode->NEXT){
        if (fNode->data < minData){
            minData = fNode->data;
            minPtr    = fNode;
        }
    }
    return minPtr;
}

插入排序:

　　按照从小到大排序.这里实现的不是就地的插入排序.而是新建立一个和拥有相同头结点的链表,不过并不会涉及节点的创建,只是节点之间的"再连接";

NodePtr CForward_List::sort_insert(){
    NodePtr 
        kNode = listHeadPtr->NEXT,
        newListHeadPtr = listHeadPtr;
    newListHeadPtr->NEXT = nullptr;

    NodePtr tmp;
    while (kNode){
        // 找到在新链表中可插入的位置
        NodePtr insertPos = findInsertPos(newListHeadPtr,kNode);
        // 临时保存下一个节点的位置
        tmp = kNode->NEXT;
        // 在新链表中进行插入操作
        sort_insert_after(insertPos,kNode);
        // 获取临时保存的下一个节点
        kNode = tmp;
    }

    return newListHeadPtr;
}

 插入排序的具体过程,保存怎么寻找插入的位置,以及在指定位置后进行插入操作.

NodePtr CForward_List::findInsertPos(NodePtr _newListHeadPtr,NodePtr _seekedNode){
    NodePtr kNode;
    for (kNode = _newListHeadPtr;kNode->NEXT;kNode = kNode->NEXT){
        if (_seekedNode->data < kNode->NEXT->data)
            return kNode;
    }
    return kNode;
}
void CForward_List:: sort_insert_after(NodePtr _insertPos,NodePtr _insertNode){
    if (!_insertPos->NEXT) 
        listEndPtr = _insertNode;
    _insertNode->NEXT = _insertPos->NEXT;
    _insertPos->NEXT = _insertNode;
}

交换两个节点元素:

void CForward_List::sort_swap(ELEMENT * _data1,ELEMENT *_data2){
    ELEMENT tmp;
    tmp = *_data1;
    *_data1 = *_data2;
    *_data2 = tmp;
}

排序操作总结:

　　以上的排序实现都是仅仅交换节点元素,并没有实现节点的"真"交换.即连带删除/插入的操作,我认为得看具体实现要求,目前这已经能够实现链表的排序了.

6.销毁操作

　　这里说明一下为什么要判断size是否等于0,因为我认为若多次链表的操作之后,在进行链表的销毁肯定会size==0的,但是留一个悬念,万一之前的操作哪里有问题(new 失败...),则会导致清理完后size不等于0.

所以留着残余的数据以便查找问题所在.

void CForward_List::deleteAllData(){
    std::cout << "deleting all node "<<std::endl;
    NodePtr node = listHeadPtr->NEXT,nextNode;
    while (node) {
        nextNode = node->NEXT;
        delete node;
        node = nullptr;
        size--;
        node = nextNode;
    }
    if(size == 0){
        listHeadPtr->NEXT = nullptr;
        listEndPtr = nullptr;
    }
}

好了,这些就是基本的链表操作,相关的代码可以在 我的github上参考源码.