拓扑链表c语言,数据结构2.2 链表的实现

链表的实现

不管链表中有无数据，我们都保持两个节点：头(m_pHead)和尾(m_pTail)

双向链表：每个节点有指向后一个节点的指针和指向上一个节点的指针。

实现代码如下：

以下代码实现了链表的增加和删除功能。

其中每段头文件中的代码都对应了.cpp文件中的代码。如头文件中的push_front那段代码，对应了.cpp文件中的**//在最前面添加元素**之后的三行代码。

.cpp文件中的代码：

#include "stdafx.h"

#include#include#include"Mylist1.h"

using namespace std;

int main(int argc, char* argv[])

{

CMylist1 mylist;

//在最前面添加元素

/*mylist.push_front(1);

mylist.push_front(2);

mylist.push_front(3);*/

//在最后面添加元素

/*mylist.push_back(0x10);

mylist.push_back(0x20);

mylist.push_back(0x30);

*/

//在任意位置添加元素

mylist.push_back(10);

mylist.push_back(20);

mylist.push_back(30);

mylist.push_back(40);

for (auto it = mylist.begin(); it != mylist.end(); it++)

{

cout << *it << " ";

}

cout << endl;

for (auto it = mylist.begin(); it != mylist.end(); it++)

{

if (*it == 30)

{

it = mylist.insert(it, 100);

cout << *it << " ";

it++;

continue;

//break;

}

cout << *it << " ";

}

cout << endl;

//(在任意位置)删除元素

//mylist.push_back(10);

//mylist.push_back(20);

//mylist.push_back(30);

//mylist.push_back(40);

//for (auto it = mylist.begin();

//it != mylist.end(); it++)

//{

//if (*it == 30)

//{

//it = mylist.erase(it);

//}

//cout << *it << " ";

//}

//cout << endl;

return 0;

}

头文件Mylist1.h中的代码：

#pragma once

#define TYPE int

struct CNode

{

public:

CNode(TYPE arg) :data(arg),

m_pNext(nullptr),

m_pPrev(nullptr)

{

}

TYPE data;

CNode* m_pNext;

CNode* m_pPrev;

};

class CMylist1

{

public:

CNode* m_pHead;

CNode* m_pTail;

CMylist1()

{

/*Head|Tail

*/

m_pHead = new CNode(TYPE());

m_pTail = new CNode(TYPE());

m_pHead->m_pNext = m_pTail;

m_pHead->m_pPrev = nullptr;

m_pTail->m_pNext = nullptr;

m_pTail->m_pPrev = m_pHead;

}

void push_front(int arg)

{

/*Head|1|2|Tail

Head|new|1|2|Tail*/

CNode* pNewNode = new CNode(arg);

CNode* pFirstNode = m_pHead->m_pNext;

m_pHead->m_pNext = pNewNode;

pFirstNode->m_pPrev = pNewNode;

pNewNode->m_pNext = pFirstNode;

pNewNode->m_pPrev = m_pHead;

}

void push_back(int arg)

{

/*

Head|1|2|Tail

Head|1|2|new|Tail

*/

CNode* pNewNode = new CNode(arg);

//改变指针之间的关系(拓扑关系)

CNode* pLastNode = m_pTail->m_pPrev;

pLastNode->m_pNext = pNewNode;

pNewNode->m_pPrev = pLastNode;

pNewNode->m_pNext = m_pTail;

m_pTail->m_pPrev = pNewNode;

}

~CMylist1()

{

}

struct iterator

{

iterator(CNode* pNode) :

m_pNode(pNode)

{

}

bool operator==(iterator otherIt)

{

return m_pNode == otherIt.m_pNode;

}

bool operator!=(iterator otherIt)

{

return m_pNode != otherIt.m_pNode;

}

iterator operator++(int)

{

//下一项

m_pNode = m_pNode->m_pNext;

return m_pNode;

}

TYPE& operator*()

{

return (m_pNode->data);

}

CNode* m_pNode;

};

iterator begin()

{

return m_pHead->m_pNext;

}

iterator end()

{

return m_pTail;

}

iterator insert(iterator it, TYPE val)

{

/*

Head|1|2|it|Tail

Head|1|2|new|it|Tail

*/

CNode* pNewNode = new CNode(val);

CNode* pItNode = it.m_pNode;

CNode*pNode2 = pItNode->m_pPrev;

pItNode->m_pPrev = pNewNode;

pNode2->m_pNext = pNewNode;

pNewNode->m_pNext = pItNode;

pNewNode->m_pPrev = pNode2;

return pNewNode;

}

iterator erase(iterator it)

{

/*

Head|1|2|it|3|Tail

Head|1|2|3|Tail

*/

CNode* pDelNode = it.m_pNode;

CNode* pPrevNode = pDelNode->m_pPrev;

CNode* pNextNode = pDelNode->m_pNext;

pPrevNode->m_pNext = pNextNode;

pNextNode->m_pPrev = pPrevNode;

if (pDelNode != nullptr)

{

delete pDelNode;

pDelNode = nullptr;

}

return pNextNode;

}

};

链表总结

时间复杂度

在头和尾插入或删除一个元素：O(1)

在指定位置插入或删除元素：O(1)

寻找等于某值的元素O(n)

访问第i个元素O(n)

由以上时间复杂度可以发现：

链表适合频繁插入和删除的场景，但不适合频繁随机访问的场景。