數據結構開發(6)：靜態單鏈表的實現
阿新 • • 發佈：2018-12-14
增加 父類 troy 導致 space header position 成員 結果
0.目錄
1.單鏈表的遍歷與優化
2.靜態單鏈表的實現
3.小結
1.單鏈表的遍歷與優化
問題：
- 如何遍歷單鏈表中的每一個數據元素？
當前單鏈表的遍歷方法：
遺憾的事實：
- 不能以線性的時間復雜度完成單鏈表的遍歷
新的需求：
- 為單鏈表提供新的方法，在線性時間內完成遍歷
設計思路 ( 遊標 )：
- 在單鏈表的內部定義一個遊標( Node* m_current )
- 遍歷開始前將遊標指向位置為0的數據元素
- 獲取遊標指向的數據元素
- 通過結點中的next指針移動遊標
提供一組遍歷相關的函數，以線性的時間復雜度遍歷鏈表。
遍歷函數原型設計：
bool move(int i, int step = 1);bool end();T current();bool next();
單鏈表的遍歷：
改進LinkList.h
#ifndef LINKLIST_H #define LINKLIST_H #include "List.h" #include "Exception.h" namespace StLib { template <typename T> class LinkList : public List<T> { protected: struct Node : public Object { T value; Node* next; }; mutable struct : public Object { char reserved[sizeof(T)]; Node* next; } m_header; int m_length; int m_step; Node* m_current; Node* position(int i) const { Node* ret = reinterpret_cast<Node*>(&m_header); for(int p=0; p<i; p++) { ret = ret->next; } return ret; } public: LinkList() { m_header.next = NULL; m_length = 0; m_step = 1; m_current = NULL; } bool insert(const T& e) { return insert(m_length, e); } bool insert(int i, const T& e) { bool ret = ((0 <= i) && (i <= m_length)); if( ret ) { Node* node = new Node(); if( node != NULL ) { Node* current = position(i); node->value = e; node->next = current->next; current->next = node; m_length++; } else { THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert new element ..."); } } return ret; } bool remove(int i) { bool ret = ((0 <= i) && (i < m_length)); if( ret ) { Node* current = position(i); Node* toDel = current->next; current->next = toDel->next; delete toDel; m_length--; } return ret; } bool set(int i, const T& e) { bool ret = ((0 <= i) && (i < m_length)); if( ret ) { position(i)->next->value = e; } return ret; } T get(int i) const { T ret; if( get(i, ret) ) { return ret; } else { THROW_EXCEPTION(IndexOutOfBoundsException, "Invalid parameter i to get element ..."); } return ret; } bool get(int i, T& e) const { bool ret = ((0 <= i) && (i < m_length)); if( ret ) { e = position(i)->next->value; } return ret; } int find(const T& e) const { int ret = -1; int i = 0; Node* node = m_header.next; while ( node ) { if( node->value == e ) { ret = i; break; } else { node = node->next; i++; } } return ret; } int length() const { return m_length; } void clear() { while ( m_header.next ) { Node* toDel = m_header.next; m_header.next = toDel->next; delete toDel; } m_length = 0; } bool move(int i, int step = 1) { bool ret = (0 <= i) && (i < m_length) && (step > 0); if( ret ) { m_current = position(i)->next; m_step = step; } return ret; } bool end() { return (m_current == NULL); } T current() { if( !end() ) { return m_current->value; } else { THROW_EXCEPTION(InvalidOperationException, "No value at current position ..."); } } bool next() { int i = 0; while( (i < m_step) && !end() ) { m_current = m_current->next; i++; } return (i == m_step); } ~LinkList() { clear(); } }; } #endif // LINKLIST_H
main.cpp測試
#include <iostream> #include "LinkList.h" using namespace std; using namespace StLib; int main() { LinkList<int> list; for(int i=0; i<5; i++) { list.insert(0, i); } for(list.move(0); !list.end(); list.next()) { cout << list.current() << endl; } return 0; }
運行結果為：
4
3
2
1
0單鏈表內部的一次封裝：
內部的封裝：
改進LinkList.h
#ifndef LINKLIST_H
#define LINKLIST_H
#include "List.h"
#include "Exception.h"
namespace StLib
{
template <typename T>
class LinkList : public List<T>
{
protected:
struct Node : public Object
{
T value;
Node* next;
};
mutable struct : public Object
{
char reserved[sizeof(T)];
Node* next;
} m_header;
int m_length;
int m_step;
Node* m_current;
Node* position(int i) const
{
Node* ret = reinterpret_cast<Node*>(&m_header);
for(int p=0; p<i; p++)
{
ret = ret->next;
}
return ret;
}
virtual Node* create()
{
return new Node();
}
virtual void destroy(Node* pn)
{
delete pn;
}
public:
LinkList()
{
m_header.next = NULL;
m_length = 0;
m_step = 1;
m_current = NULL;
}
bool insert(const T& e)
{
return insert(m_length, e);
}
bool insert(int i, const T& e)
{
bool ret = ((0 <= i) && (i <= m_length));
if( ret )
{
Node* node = create();
if( node != NULL )
{
Node* current = position(i);
node->value = e;
node->next = current->next;
current->next = node;
m_length++;
}
else
{
THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert new element ...");
}
}
return ret;
}
bool remove(int i)
{
bool ret = ((0 <= i) && (i < m_length));
if( ret )
{
Node* current = position(i);
Node* toDel = current->next;
current->next = toDel->next;
destroy(toDel);
m_length--;
}
return ret;
}
bool set(int i, const T& e)
{
bool ret = ((0 <= i) && (i < m_length));
if( ret )
{
position(i)->next->value = e;
}
return ret;
}
T get(int i) const
{
T ret;
if( get(i, ret) )
{
return ret;
}
else
{
THROW_EXCEPTION(IndexOutOfBoundsException, "Invalid parameter i to get element ...");
}
return ret;
}
bool get(int i, T& e) const
{
bool ret = ((0 <= i) && (i < m_length));
if( ret )
{
e = position(i)->next->value;
}
return ret;
}
int find(const T& e) const
{
int ret = -1;
int i = 0;
Node* node = m_header.next;
while ( node )
{
if( node->value == e )
{
ret = i;
break;
}
else
{
node = node->next;
i++;
}
}
return ret;
}
int length() const
{
return m_length;
}
void clear()
{
while ( m_header.next )
{
Node* toDel = m_header.next;
m_header.next = toDel->next;
destroy(toDel);
}
m_length = 0;
}
bool move(int i, int step = 1)
{
bool ret = (0 <= i) && (i < m_length) && (step > 0);
if( ret )
{
m_current = position(i)->next;
m_step = step;
}
return ret;
}
bool end()
{
return (m_current == NULL);
}
T current()
{
if( !end() )
{
return m_current->value;
}
else
{
THROW_EXCEPTION(InvalidOperationException, "No value at current position ...");
}
}
bool next()
{
int i = 0;
while( (i < m_step) && !end() )
{
m_current = m_current->next;
i++;
}
return (i == m_step);
}
~LinkList()
{
clear();
}
};
}
#endif // LINKLIST_H問題：
- 封裝 create 和 destroy 函數的意義是什麽？
2.靜態單鏈表的實現
單鏈表的一個缺陷：
- 觸發條件
- 長時間使用單鏈表對象頻繁增加和刪除數據元素
- 可能的結果
- 堆空間產生大量的內存碎片，導致系統運行緩慢
新的線性表
- 設計思路：
- 在“單鏈表”的內部增加一片預留的空間，所有的Node對象都在這片空間中動態創建和動態銷毀。
靜態單鏈表的繼承層次結構：
靜態單鏈表的實現思路：
- 通過模板定義靜態單鏈表類( StaticLinkList )
- 在類中定義固定大小的空間( unsigned char[] )
- 重寫 create 和 destroy 函數，改變內存的分配和歸還方式
- 在Node類中重載 operator new，用於在指定內存上創建對象
（在StLib中實現StaticLinkList.h）：
#ifndef STATICLINKLIST_H
#define STATICLINKLIST_H
#include "LinkList.h"
namespace StLib
{
template <typename T, int N>
class StaticLinkList : public LinkList<T>
{
protected:
typedef typename LinkList<T>::Node Node;
struct SNode : public Node
{
void* operator new(size_t size, void* loc)
{
(void)size;
return loc;
}
};
unsigned char m_space[sizeof(SNode) * N];
int m_used[N];
Node* create()
{
SNode* ret = NULL;
for(int i=0; i<N; i++)
{
if( !m_used[i] )
{
ret = reinterpret_cast<SNode*>(m_space) + i;
ret = new(ret)SNode();
m_used[i] = 1;
break;
}
}
return ret;
}
void destroy(Node *pn)
{
SNode* space = reinterpret_cast<SNode*>(m_space);
SNode* psn = dynamic_cast<SNode*>(pn);
for(int i=0; i<N; i++)
{
if( psn == (space + i) )
{
m_used[i] = 0;
psn->~SNode();
}
}
}
public:
StaticLinkList()
{
for(int i=0; i<N; i++)
{
m_used[i] = 0;
}
}
int capacity()
{
return N;
}
};
}
#endif // STATICLINKLIST_Hmain.cpp測試
#include <iostream>
#include "StaticLinkList.h"
using namespace std;
using namespace StLib;
int main()
{
StaticLinkList<int, 5> list;
for(int i=0; i<5; i++)
{
list.insert(0, i);
}
for(list.move(0); !list.end(); list.next())
{
cout << list.current() << endl;
}
return 0;
}運行結果為：
4
3
2
1
0Q & A：
- LinkList 中封裝 create 和 destroy 函數的意義是什麽？
- 為靜態單鏈表( StaticLinkList )的實現做準備。StaticLinkList 與 LinkList 的不同僅在於鏈表結點內存分配上的不同；因此，將僅有的不同封裝於父類和子類的虛函數中。
3.小結
- 單鏈表的遍歷需要在線性時間內完成
- 在單鏈表內部定義遊標變量，通過遊標變量提高效率
- 遍歷相關的成員函數是相互依賴，相互配合的關系
- 封裝結點的申請和刪除操作更有利於增強擴展性
- 順序表與單鏈表相結合後衍生出靜態單鏈表
- 靜態單鏈表是 LinkList 的子類，擁有單鏈表的所有操作
- 靜態單鏈表在預留的空間中創建結點對象
- 靜態單鏈表適合於頻繁增刪數據元素的場合( 最大元素個數固定 )
數據結構開發(6)：靜態單鏈表的實現