内嵌散列表的双链表

最新推荐文章于 2024-07-25 22:14:03 发布
最新推荐文章于 2024-07-25 22:14:03 发布
阅读量635 收藏
点赞数
文章标签： class header null insert delete 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaogenzi/article/details/5617625
版权

 

 

#include <iostream>
#include <string>
using namespace std;

//默认情况下动态数组的长度为2

template <class DataType>
class Array
{
public:
 Array(int size = 2);
 Array(const Array<DataType> &copy);
 Array<DataType>& operator=(const Array<DataType> &right);
 ~Array();
 DataType &operator[](int index);
 void ChangeSize(int size);
 int GetSize()const;
private:
 inline void DeepCopy(const Array<DataType> &origin);
 DataType *element;
 int capacity;
};

template< class DataType>
Array<DataType>::Array(int size)
{
 if(size < 1)
 {
       capacity = 2;
 }
 else
 {
  capacity = size;
 }
 element = new DataType[size];
}

template <class DataType>
Array<DataType>::Array(const Array<DataType> &copy)
{
 DeepCopy(copy);
}

template <class DataType>
Array<DataType>& Array<DataType>::operator=(const Array<DataType> &right)
{
 if(this == &right)
 {
  return *this;
 }
 delete []element;
 DeepCopy(right);
 return *this;
}

template <class DataType>

Array<DataType>::~Array()
{
 delete []element;
}

template < class DataType>
DataType& Array<DataType>::operator[](int index)
{

 return element[index];
}

template <class DataType>
void Array<DataType>::ChangeSize(int size)
{
 if((size<1) || (size==capacity))
 {
  return;
 }
 DataType *newelement = new DataType[size];
 int limit = (size>capacity) ? capacity : size;
 for(int i=0; i<limit; i++)
 {
  newelement[i] = element[i];
 }
 delete []element;
 element = newelement;
 capacity = size;
}

template<class DataType>
inline void Array<DataType>::DeepCopy(const Array<DataType> &origin)
{
 capacity = origin.capacity;
 for(int i=0; i<capacity; i++)
 {
  element[i] = origin.element[i];
 }
}

template<class DataType>
int Array<DataType>::GetSize()const
{
 return capacity;
}

//列表类。
//对先前的结点进行修改
template <class DataType>
struct Node
{
 DataType info;
 Node<DataType> *next;
 Node<DataType> *dlnext;
 Node<DataType> *dlback;
};

template <class DataType>
class LinkedList
{
public:
 LinkedList();
 ~LinkedList();
 LinkedList(const LinkedList<DataType> &copy);
 LinkedList<DataType>& operator=(const LinkedList<DataType> &right);
 void Insert(const DataType &element);
 bool Remove(DataType &element);
 bool Retrieve(DataType &element);
 bool Find(const DataType &element);
 bool Replace(const DataType &element);
 bool IsEmpty()const;
 void MakeEmpty();
 Node<DataType> *GetCurrent() const;     //配合双链表得到当前插入位置。

private:
 inline bool first(DataType &element);
 inline bool getNext(DataType &element);
 inline void DeepCopy(const LinkedList<DataType> &origin);
 Node<DataType> *header;
    Node<DataType> *current;
};


template <class DataType>
LinkedList<DataType>::LinkedList()
{
 header = NULL;
}

template <class DataType>
LinkedList<DataType>::~LinkedList()
{
 MakeEmpty();
}

template <class DataType>
LinkedList<DataType>::LinkedList(const LinkedList<DataType> &copy)
{
 DeepCopy(copy);
}

template <class DataType>
LinkedList<DataType>& LinkedList<DataType>::operator=(const LinkedList<DataType> &right)
{
 if(&right == this)
 {
  return *this;
 }
 MakeEmpty();
 DeepCopy(right);
 return *this;
}


//对先前的列表类进行修改
//增加一个GetCurrent()函数，得到当前插入结点的位置
template <class DataType>
Node<DataType> *LinkedList<DataType>::GetCurrent() const
{
 return current;
}

template <class DataType>
void LinkedList<DataType>::Insert(const DataType &element)
{
 if(NULL == header)
 {
  header = new Node<DataType>;
  header->info = element;
  header->next = NULL;   //NULL结束标记就像字符串里的/0一样很重要。
  current = header;          //在插入操作后current值不为NULL，而是指向新结点
  return;
 }
 Node<DataType> *temp = new Node<DataType>;
 temp->info = element;
 temp->next = header;
 header = temp;
 current = header;     //需要将current 指向当前插入位置。。。
}

template <class DataType>
bool LinkedList<DataType>::Remove(DataType &element)
{
 current = NULL;
 Node<DataType> *temp = header;
 if(header->info == element)
 {
  header = header->next;
  element = temp->info;
  delete temp;
  return true;
 }
 while(temp->next != NULL)
 {
  if(temp->next->info == element)
  {
   Node<DataType> *del = temp->next;
   element = del->info;
   temp->next = del->next;
   delete del;
   return true;
  }
  temp = temp->next;
 }
 return false;
}

template <class DataType>
bool LinkedList<DataType>::Retrieve(DataType &element)
{
 if(!Find(element))
 {
  return false;
 }
 element = current->info;
 return true;
}

template <class DataType>
bool LinkedList<DataType>::Find(const DataType &element)
{
 DataType temp;
 if(!first(temp))
 {
          return false;
 }
 do
 {
  if(temp == element)
  {
          return true;
  }
 } while (getNext(temp));
          return false;
}
template <class DataType>

bool LinkedList<DataType>::Replace(const DataType &element)
{
 if(NULL == current)
 {
       return false;
 }
 current->info = element;
       return true;
}

template <class DataType>
bool LinkedList<DataType>::IsEmpty()const
{
       return NULL == header;
}

template <class DataType>

void LinkedList<DataType>::MakeEmpty()
{
 while(NULL != header)
 {
  current = header;
  header = header->next;
  delete current;
 }
 current = NULL;
}

template <class DataType>
inline bool LinkedList<DataType>::first(DataType &element)
{
 if(NULL == header)
 {
      current = NULL;
      return false;
 }
 current = header;
 element = current->info;
 return true;
}

template <class DataType>
inline bool LinkedList<DataType>::getNext(DataType &element)
{
 if(NULL == current)
 {
     return false;
 }
 if(NULL == current->next)
 {
     current = NULL;
     return false;
 }
 current = current->next;
 element = current->info;
 return true;
}

template <class DataType>
inline void LinkedList<DataType>::DeepCopy(const LinkedList<DataType> &origin)
{
 header = current = NULL;
 if(NULL == origin.header)
 {
  return;
 }
 header = origin.header;
 header->info = origin.header->info;
 if(origin.header->info == origin.current)
 {
  current = header;
 }
 Node<DataType> *copy = header;
 Node<DataType> *originptr = origin.header;
 while(originptr->next != NULL)
 {
  originptr = originptr->next;
  copy->next = new Node<DataType>;
  copy = copy->next;
  copy->info = originptr->info;
  if(originptr == origin.current)
  {
   current = copy;
  }
 }
 header->next = NULL;
}

 

//散列表（hashtable)

template <class DataType>
class HashTable
{
public:
 HashTable(int (*pFunc)(const DataType &), int size);
 bool Insert(const DataType &element);
 bool Retrieve(DataType &element);
 bool Remove(DataType &element);
 void MakeEmpty();
 int GetSize() const;
 int (*GetHashFuc() const)(const DataType &element);                                      //返回函数指针
 void SetHashFuc(int (*pfunc)(const DataType &element));
 void ChangeSize(int size);
 Node<DataType> *GetCurrent();
private:
 int position;        
 Array< LinkedList<DataType> > array;    //动态数组内嵌单链表
 int (*hashfunc)(const DataType &element);   //散列函数应由主程序员自己生成，所以用一个函数指针。
};

template <class DataType>
void HashTable<DataType>::MakeEmpty()
{
 int nLimit = array.GetSize();
 for(int i=0; i<nLimit; i++)
 {
  array[i].MakeEmpty();
 }

}


template <class DataType>
void HashTable<DataType>::ChangeSize(int size)
{
 array.ChangeSize(size);
}

 

template <class DataType>
int (*HashTable<DataType>::GetHashFuc() const)(const DataType &element)    
{
 return hashfunc;
}

 

template <class DataType>
void HashTable<DataType>::SetHashFuc(int (*pfunc)(const DataType &element))
{
 hashfunc = pfunc;
}

 

template <class DataType>        
Node<DataType> *HashTable<DataType>::GetCurrent()
{
 return array[position].GetCurrent();  //array不能是一个左值。
}

 

template <class DataType>
HashTable<DataType>::HashTable(int (*pFunc)(const DataType &), int size)
:array(size)
{
 hashfunc = pFunc;
}

 

template <class DataType>
int HashTable<DataType>::GetSize() const
{
 return array.GetSize();
}

 

template <class DataType>
bool HashTable<DataType>::Insert(const DataType &element)
{
 position = hashfunc(element);
 if((position<0) || (position>=array.GetSize()))
 {
  return false;
 }
 array[position].Insert(element);
 return true;
}

 

template <class DataType>
bool HashTable<DataType>::Retrieve(DataType &element)
{
 position = hashfunc(element);
 if((position<0) || (position>=array.GetSize()))
 {
  return false;
 }
 if(!array[position].Retrieve(element))
 {
  return false;
 }
 return true;
}

 

template <class DataType>
bool HashTable<DataType>::Remove(DataType &element)
{
 position = hashfunc(element);
 if((position<0) || (position>=array.GetSize()))
 {
  return false;
 }
 if(!array[i].Remove(element))
 {
  return false;
 }
 return true;
}

 

//内嵌散列表的双链表，一个很重要的数据结构。

template <class DataType>
class DoublyLinkedList
{
public:
 DoublyLinkedList(int(*pFunc)(const DataType &element), int size);
 ~DoublyLinkedList();
 DoublyLinkedList(const DoublyLinkedList &copy);    //复制构造函数
 DoublyLinkedList<DataType> &operator=(const DoublyLinkedList<DataType> &right);
 bool Insert(const DataType &element);
 bool Find(const DataType &element);
 bool Retrieve(DataType &element);
 bool Remove(DataType &element);
 bool Replace(const DataType &element);
 void MakeEmpty();
 bool IsEmpty() const;
private:
 inline void DeepCopy(const DoublyLinkedList<DataType> &origin);
 Node<DataType> *header;
 Node<DataType> *trailer;
 Node<DataType> *current;
 HashTable<DataType> hashtable;
 Node<DataType> headerNode;
 Node<DataType> trailerNode;
};

 

template <class DataType>
DoublyLinkedList<DataType>::DoublyLinkedList(int(*pFunc)(const DataType &element), int size)
:hashtable(pFunc, size)
{
 header = &headerNode;
 trailer = &trailerNode;
 header->dlnext = trailer;
 trailer->dlback = header;
 current = trailer;                                                         //没有当前位置current批向尾结点，符全思路。
}

 

template <class DataType>
DoublyLinkedList<DataType>::~DoublyLinkedList()
{
      MakeEmpty();
}

 

template <class DataType>
DoublyLinkedList<DataType>::DoublyLinkedList(const DoublyLinkedList &copy)    //复制构造函数
{
     DeepCopy(copy);
}

 

template <class DataType>
DoublyLinkedList<DataType> &DoublyLinkedList<DataType>::operator=(const DoublyLinkedList<DataType> &right)
{
 if(&right == this)
 {
  return *this;
 }
 MakeEmpty();
 DeepCopy(right);
 return *this;
}

 

template<class DataType>
bool DoublyLinkedList<DataType>::Insert(const DataType &element)
{
 if(!hashtable.Insert(element))
 {
  return false;
 }
 current = hashtable.GetCurrent();
 current->dlnext = header->dlnext;
 current->dlback = header;
 header->dlnext->dlback = current;
 header->dlnext = current;
 current = trailer;                                                              //每个新插入的结点做为新结点,插入后没有当前位置
 return true;
}

 

template <class DataType>
bool DoublyLinkedList<DataType>::Find(const DataType &element)
{
 DataType temp = element;
 if(!hashtable.Retrieve(temp))
 {
  current = trailer;
  return false;
 }
 current = hashtable.GetCurrent();
 return true;
}

 

template <class DataType>
bool DoublyLinkedList<DataType>::Retrieve(DataType &element)
{
 if(!hashtable.Retrieve(element))
 {
  current = trailer;
  return false;
 }
 current = hashtable.GetCurrent();
 return true;
}

 

template <class DataType>
bool DoublyLinkedList<DataType>::Remove(DataType &element)
{
 if(!hashtable.Retrieve(element))
 {
  return false;
 }
 current = hashtable.GetCurrent();
 current->dlback->dlnext = current->dlnext;
 current->dlnext->dlback = current->dlback;
 hashtable.Remove(element);                                                               //保证安全，删除操作应该在最后完成。
 current = trailer;
 return true;
}

 

template <class DataType>
bool DoublyLinkedList<DataType>::Replace(const DataType &element)
{
 if(trailer == current)                                             //敲过几次后，发现还是有规律可寻的。和上面的列表类对比一下就能发现共同点
 {
       return false;
 }
 current->info = element;
 return true;
}

template <class DataType>
void DoublyLinkedList<DataType>::MakeEmpty()
{
 hashtable.MakeEmpty();
 current = trailer;
 header->dlnext = trailer;
 trailer->dlback = current;
}

 

template <class DataType>
bool DoublyLinkedList<DataType>::IsEmpty() const
{
 return header->dlnext == trailer;                           //外形上是一个双链表
}

 

//深复制函数
//在构造函数和重载赋值运算符中使用

//所以要对可能两方面的使用都做一些物殊处理

//

template <class DataType>
void DoublyLinkedList<DataType>::DeepCopy(const DoublyLinkedList<DataType>& origin)
{

//在复制构造函数中使用时，保证左右对象的数组容量相同。
 if(hashtable.GetSize() != origin.hashtable.GetSize())                           //保证动态数组大小和右操作数大小相同。
 {                                                                                                           //
   hashtable.ChangeSize(origin.hashtable.GetSize());
 }
 hashtable.SetHashFuc(origin.hashtable.GetHashFuc());   //设置散列函数

//实现构造函数功能
 header = &headerNode;
 trailer = &trailerNode;
 header->dlnext = trailer;
 trailer->dlback = header;
 current = trailer;
 Node<DataType> *SaveCurrent = NULL;
 Node<DataType> *originptr = origin.trailer->dlback;
 while(originptr->dlback != origin.header)
 {
  originptr = originptr->dlback;
  Insert(originptr);
  if(originptr == origin.current)
  {
   SaveCurrent = header->dlnext;                                                    

  }
 }
 current = SaveCurrent;           
}


// template<class DataType>
// void  HashTable<DataType>::MakeEmpty()
// {
//  int nLen = array.GetSize();
//  for(int i=0; i<nLen; i++)
//  {
//   array[i].MakeEmpty();
//  }
// }
//
struct MyStruct    
{  
    string str;  
    int num;  
    bool operator==(const MyStruct & r);
 friend ostream& operator<<(ostream &out, const MyStruct &right);
};  

ostream& operator<<(ostream &out, const MyStruct &right)
{
 out<<"Name is: "<<right.str<<endl;
 out<<" age is: "<<right.num<<endl;
 out<<endl;
 return  out;
}
bool MyStruct::operator==(const MyStruct & r)
{
 return str == r.str;
}
const int SIZE1=97,SIZE2=199;
int hash1(const MyStruct & obj);  

int hash2(const MyStruct & obj);  
int  main()  
{  
 DoublyLinkedList<MyStruct> list(hash1, SIZE1);
 MyStruct stu;
 stu.str = "zhaozigeng";
 stu.num = 26;

 MyStruct stu2;
 stu2.str ="yujingkun";
 stu2.num = 24; 
 list.Insert(stu);
 list.Insert(stu2);

 MyStruct stu3;
 stu3.str = "yujingkun";
 list.Retrieve(stu3);
 cout<<stu3;
   
 stu3.num = 2000;
 list.Replace(stu3);
 cout<<stu3;

    return 0; 
}  


int hash1(const MyStruct & obj)  
{  
    int sum=0;  
    for (int i=0;i<3 && i<int(obj.str.length());i++)  
    {  
        sum+=obj.str[i];  
    }  
    return sum % SIZE1;  
}  

子庚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Unity内嵌浏览器.zip
04-29
Unity内嵌浏览器是一种在Unity开发环境中集成Web浏览功能的技术，主要通过特定的插件实现。在Unity游戏或应用中，内嵌浏览器可以让用户无需离开应用就能访问网页内容，提升用户体验。本篇将深入探讨Unity内嵌浏览器...
java内嵌浏览器
03-12
本代码J2SE代码，采用swt编程，实现内嵌浏览器，下载后找到项目中的两个类中的main运行即可。由于IE和Chrome内核不一样，所以采用jar包不一样，其中Chrome使用的jxbrowser，该项目中的jxbrowser已破解，放心使用。
散列表链接法用双向链表的原因
scutcoder的专栏
09-19 828
算法导论上说散列表链接法用双向链表是因为双向链表删除的时间为O(1)，比单向链表快。看书的时候在这里卡住了，后来百度了一下才知道单向链表删除操作要先得到前一个结点，而双向链表不用，自然就比较快了。
数据结构之Linux Kernel双向链表（一）
Unixer
12-26 740
Linux Kernel双向链表
散列表 + 双向链表应用----LinkedHashMap
帆心
11-18 308
LinkedHashMap是HashMap的一个子类 其在HashMap的基础上添加了一个双向链表来保证元素的插入和取出顺序一致性 那么LinkedHashMap是如何通过双向链表来保证元素的插入有序性的 ? LinkedHashMap在添加数据时 把元素添加到散列表的基础之上 还会把元素插入到维护的双向链表的尾部 (如此 在遍历LinkedHashMap时 直接遍历双向链表即可) 而HashMap在遍历时 会遍历一整个散列表 所以HashMap的遍历速度和其数组的长度有关系 而Link.
散列表+双向链表实现LRU算法
骆超
08-19 773
缓存是一种提高数据读取性能的技术，比如常见的CPU缓存，数据库缓存以及浏览器缓存。 缓存的大小有限，当缓存被用满时，哪些数据应该被清理出去,哪些数据应该被保留？ 缓存淘汰策略，常见的有三种，先进先出策略FIFO,最少使用策略LFU,最近最少使用策略LRULeast Recently Used）。 散列表+双向链表实现LRU算法 我们需要维护一个按照访问时间从大到小有序排列的链表结构。 因为缓存大小...
Linux内核中链表和散列表的实现原理揭秘
weixin_34278190的博客
07-14 130
                                                                                                                                                                          By沈东良(良少)http...
C++数据结构：Python风格双向链表Pylist的实现
攻城狮的博客
05-27 1304
线性顺序表（链表）已经完成了单向链表基本的插入、取值、删除等操作，本文将在前文的基础上更进一步完善其功能。参照Python的 List 列表的函数常用功能来实现。如+运算直接将两个列表合并，[] 运算赋值、取值。笔者是很喜欢python中列表这种骚操作的，本文就在C++中实现它。当然基本的C++语法规则笔者是没法改变的。赋值得用{}，类型还是要声明的，泛型自然是可以的，但你也别想着在一个列表中同时塞入 string 和 int。
linux内核的双链表list_head、散列表hlist_head
weixin_30322405的博客
07-17 316
一、双链表list_head 1、基本概念 linux内核提供的标准链表可用于将任何类型的数据结构彼此链接起来。 不是数据内嵌到链表中，而是把链表内嵌到数据对象中。 即：加入链表的数据结构必须包含一个类型为list_head的成员，其中包含了正向和反向指针。 struct list_head { struct list_head *next, *prev; }; 由...
linux内核链表c实现,C语言 Linux内核链表（企业级链表）
weixin_33873956的博客
05-09 145
//Linux内核链表(企业级链表)#define _CRT_SECURE_NO_WARNINGS#include#include#include#define offscfof(TYPE,MEMBER) ((size_t)&((TYPE *)0)->MEMBER)#define container_of(ptr,type,member) (type *)((char *)ptr-o...
unity内嵌网页插件.rar
12-28
Unity内嵌网页插件是Unity开发中的一种技术，它允许开发者在Unity游戏中或者应用程序中集成一个Web浏览器组件，用户可以直接在游戏内部浏览网页内容。这种功能对于实现互动教程、在线帮助系统、游戏内置商店或者实时...
GCC.rar_内嵌汇编
09-24
内嵌汇编是GCC（GNU Compiler Collection）提供的一项特性，允许程序员在高级语言代码中直接插入汇编语言指令。这在处理特定硬件功能、优化性能或解决与底层硬件交互的问题时非常有用。以下是对内嵌汇编的详细解释：...
MFC list control 内嵌按钮以及样式
07-05
在Microsoft Foundation Class (MFC)库中，List Control是一个强大的组件，它允许程序员展示列表数据，包括文本、图像以及自定义元素。标题“MFC list control 内嵌按钮以及样式”指的是如何在List Control中嵌入...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 789
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
（数据结构）二叉树
2401_83526138的博客
07-24 622
树是一种非线性的数据结构，它是由n（n>=0）个有限节点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：有一个特殊的节点，称为根节点，根节点没有前驱节点除根节点外，其余节点被分成M（M > 0）个互不相交的集合T1, T2, ......, Tm，其中每一个集合Ti(1 <= i <= m)又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继树是递归定义的。
【C语言】数组栈的实现
最新发布
2301_80840905的博客
07-25 746
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端
数据结构——双向链表及其总结
2406_83392683的博客
07-23 344
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
7.24数据结构
2301_81236242的博客
07-24 603
1>树形结构：表示数据元素之间存在一对多的关系2>树：是由一个根节点多个子树构成的树形结构3>节点：就是树中的数据元素4>父亲节点：当前节点的直接上级节点5>孩子节点：当前节点的直接下架节点6>祖先节点：当前节点的直接或间接上级节点7>子孙节点：当前节点的直接或间接下级节点8>兄弟节点：拥有相同父节点的所有节点互称为兄弟节点9>堂兄弟节点：其父节点在同一层的所有节点，互为堂兄弟节点10>根节点：没有父节点的节点11>叶子节点：没有子节点的节点称为叶子节点。
Python内嵌列表
10-13
Python内嵌列表是指列表中嵌套有列表的数据结构。在Python中，可以通过列表嵌套列表的方式来创建多维数组或矩阵等数据结构。例如，[[1,2,3],[4,5,6],[7,8,9]]就是一个二维数组，其中每个元素都是一个包含三个元素的列表。 引用中提到了Python中常见的嵌套现象，其中包括了列表中嵌套有列表。引用中给出了一个例子，展示了如何将一个嵌套列表中的元素提取出来并放入一个新的列表中。引用中则给出了一个例子，展示了如何使用递归函数来遍历一个嵌套列表中的所有元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值