C++学习总结——顺序存储，链式存储，索引存储，哈希存储的优缺点，以及vector数组，list链表，十字链表，索引结构，hash表的实现

1.顺序存储  

平均时间复杂度为O(n)   空间复杂度为O(0)

查找，删除，增加的时间复杂度为O(0),修改的时间复杂度为O(1)

优点：存储空间紧凑，容易进行查找

缺点：插入删除需要移动大量元素。需要分配大量空间

2.索引存储

元素个数为M 索引数为N   查找的时间复杂度为O(M/N)  插入删除增加的时间复杂度为O(1)
本质为一个指针数组，数组的每一个元素可以是动态数组，链表，树或者图

#pragma once
template<class T>
class myvector
{
public:
myvector();
~myvector();
void push_back(T t);
T* find(T t);
void show();
void change(T* pos, T t);
void del(T t);
void insert(int pos,T t);
T operator [](int i);
public:
T* p;
int n;
int reallen;
};
#include "myvector.h"
#include <iostream>

using namespace std;
/*
myvector();
~myvector();
void push_back(T t);
T *find(T t);
void show();
void change(T *pos, T t);
void del(T t);
void insert(T *pos,T t);
*/

template<class T>
myvector<T>::myvector()
{
p = nullptr;
n = reallen = 0;
}

template<class T>
myvector<T>::~myvector()
{
if (p != nullptr)
{
delete[]p;
n = reallen = 0;
}

}
//从尾部插入数据
template<class T>
void myvector<T>::push_back(T t)
{
if (p == nullptr)
{
p = new T;
*p = t;
n = reallen = 1;
}
else
{
T* ptemp = new T[n + 1];
for (int i = 0;i < n;i++)
{
ptemp[i] = p[i];
}
delete[]p;

p = ptemp;

p
= t;

reallen += 1;
n += 1;

}
}
//查找数据元素返回位置
template<class T>
T* myvector<T>::find(T t)
{
for (int i = 0;i < reallen;i++)
{
if (p[i] == t)
{
return p + i;
}
}
return nullptr;
}
//打印数据元素
template<class T>
void myvector<T>::show()
{
if (p == nullptr)
{
return;
}
for (int i = 0;i < reallen;i++)
{
cout << "p[" << i<<"]="<<p[i] << endl;
}

}
//改变数据元素
template<class T>
void myvector<T>::change(T *pos, T t)
{
if (pos == nullptr)
{
return;
}
else
{
*pos = t;
}
}
//删除数据
template<class T>
void myvector<T>::del(T t)
{
int pos = -1;
for (int i = 0;i < reallen;i++)
{
if (p[i] == t)
{
pos = i;
break;
}
}
if (pos != -1)
{
if (pos == reallen - 1)
{
reallen -= 1;
}
else
{
for (int i = pos;i < reallen - 1;i++)
{
p[i] = p[i + 1];
}
}
}
}
//插入数据
template<class T>
void myvector<T>::insert(int pos, T t)
{
if (pos>0 && pos<= n)
{

//重新分配内存并拷贝

T *ptemp = new T[n + 1];//重新分配内存

for (int i = 0; i < n; i++)
{
*(ptemp + i) = *(p + i);//拷贝
}

delete []p;
p = ptemp;
reallen += 1;
n += 1;

}
for(int i = reallen-2;i>=pos;i--)
{
p[i+1] = p[i];//往前移动
}
p[pos] = t;
}
//重载操作符
template<class T>
T myvector<T>::operator[](int i)
{
if (i < 0 || i >= reallen)
{
return NULL;
}
return p[i];
}
#include "myvector.h"
#include "myvector.cpp"
#include<iostream>
//顺序存储
using namespace std;
void main1()
{
myvector<int> myv;

myv.push_back(12);
myv.push_back(15);
myv.push_back(13);
myv.push_back(10);

myv.insert(2,9);

cout<<myv.find(12)<<endl;

myv.change(myv.find(13),8);
myv.show();

cin.get();

}
//索引存储
void main()
{
myvector<int> mv1;
mv1.push_back(1);
mv1.push_back(2);
mv1.push_back(3);
mv1.push_back(4);
mv1.push_back(5);
myvector<int> mv2;
mv2.push_back(11);
mv2.push_back(12);
mv2.push_back(13);
mv2.push_back(14);
mv2.push_back(15);

myvector<myvector<int>*> mvv;
//存储的是vector类型的地址，通过地址查找相应内存块获得数据
mvv.push_back(&mv1);
mvv.push_back(&mv2);
mvv[0]->show();
mvv[1]->show();

cin.get();

}

3.链式存储：

明确元素位置后，增加，插入，删除，修改的时间复杂度都为O(1), 查找的时间复杂度为O(n)

优点：增加，删除

缺点：查找复杂
#pragma once

template <class T>
class node
{
public:
node();
~node();
public:
T data;
node* pnext;
};
#pragma once
#include "node.h"
template<class T>
class list
{
public:
list();
~list();
void add(T t);
void show();
node<T>* find(T t);
void change(node<T> *pos,T newt);//修改
void insert(T oldt,T newt);
bool deletel(T t);
void deletesame();//删除相同元素
bool deleteall();
bool clear();
void rev();
void sort();
int getnum();
void merge(list<T> &ll);

public:
node<T> *phead;
};
#include "node.h"
#include<iostream>
using namespace std;
template<class T>
node<T>::node()
{
}
template<class T>
node<T>::~node()
{
}
#include "list.h"
#include "node.h"
#include "node.cpp"
#include<iostream>
using namespace std;
template<class T>
list<T>::list()
{
this->phead = nullptr;
cout << "list creat" << endl;
}

template<class T>
list<T>::~list()
{
cout << "list ruin" << endl;
}
//增加结点
template<class T>
void list<T>::add(T t)
{
node<T> *p = new node<T>;//分配结点
p->data = t;
p->pnext = nullptr;
if (phead == nullptr)
{
this->phead = p;
}
else
{
node<T> *pt=phead;
while(pt->pnext!=nullptr)
{
pt= pt->pnext;
}
pt->pnext= p;
}

}
//打印结点
template<class T>
void list<T>::show()
{
node<T> *ptemp = phead;
if (phead == nullptr)
{
cout << "null"<<endl;
return;
}
while (ptemp!= nullptr)
{
cout << ptemp->data << "->";

ptemp = ptemp->pnext;
}
cout << endl;
}
//查找结点
template<class T>
node<T>* list<T>::find(T t)
{
node<T> *p = phead;
while (p != nullptr)
{
if (p->data == t)
{
return p;
}
p = p->pnext;
}
return nullptr;

}
//改变结点的值
template<class T>
void list<T>::change(node<T> *pos, T newt)
{
if (pos == nullptr)
{
return;
}
pos->data = newt;
}
//结点的插入运算，在指定结点前面插入结点，
template<class T>
void list<T>::insert(T oldt, T newt)
{
node<T> *p = this->find(oldt);//查找指定结点的位置
if (p != nullptr)
{
node<T> *p1, *p2;
p1 = phead;
p2 = p1->pnext;
while (p2!=p)
{
p1= p2;
p2 = p1->pnext;
}
//插入新的节点
node<T> *pnew = new node<T>;
pnew->data = newt;
p1->pnext = pnew;
pnew->pnext = p2;
}

}
//删除结点
template<class T>
bool list<T>::deletel(T t)
{
cout << "delete "<< t<<endl;
node<T> *p = this->find(t);
//判断所删除的数据是否存在，链表是否为空
if (phead == nullptr || p== nullptr)
{
return false;
}
else
{
if (p == phead)//判断所删除的结点是否为头结点
{
phead = p->pnext;
delete p;
return true;
}
//找到所删除的结点以及指向它的结点，令指向他的结点指向该结点的下一个结点，并删除该结点
node<T> *p1=phead,*p2=p1->pnext;
while(p2!=p)
{
p1 = p2;
p2 = p1->pnext;
}
p1->pnext = p2->pnext;
delete p2;
return true;
}
return false;
}
//删除相同结点
template<class T>
void list<T>::deletesame()//删除相同元素
{
cout << "deletesame" << endl;
//将链表的值从头结点开始依次与后面结点的值比较，用指针pf记录被比较结点的前一个结点，如果比较值相等则删除后面的结点，让前一个结点指向被删除结点的后一个结点。
for (node<T> *pt1 = phead;pt1 != nullptr;pt1 = pt1->pnext)
{
node<T> *pf = pt1;//记录前一个结点
for (node<T> *pt2 = pf->pnext;pt2 != nullptr;pt2 = pf->pnext)
{

if (pt1->data==pt2->data)
{
//删除相等结点，让前一个结点指向被删除结点的后一个结点
pf->pnext = pt2->pnext;
delete pt2;
}
else
{
pf = pt2;//如果值不相等则向后移动
}
}
}
/*
node<T> *p1,*p2;
p1=phead->pnext;
p2=phead;
while(p1!=nullptr)
{
if(p1->data==p2->data)
{
p2->pnext=p1->pnext;
delete p1;
p1=p2->pnext;
}
else
{
p2=p1;
p1=p1->pnext;
}
}

*/
}
//删除所有结点
template<class T>
bool list<T>::deleteall()
{
cout << "deleteall" << endl;
node<T> *ptemp=nullptr;
while (phead->pnext!=nullptr)
{
ptemp = phead->pnext;
delete phead;
phead = ptemp;
this->show();
}
delete phead;
phead=nullptr;
return true;
}
//清空链表
template<class T>
bool list<T>::clear()
{
node<T> *p1, *p2;
p1 = phead->pnext;
while (p1!=nullptr)
{
p2 = p1->pnext;
delete p1;
p1=p2
}
delete phead;
phead = nullptr;
return true;
}
//链表反转
/*
a -> b -> c -> d -> e
p1 <- p2 p3
p1 <- p2 p3
p1 <- p2 p3
p1 <- p2 p3
p1 p2 p3
nullptr<-phead phead nullptr
*/
template<class T>
void list<T>::rev()
{
cout << "rev " << endl;
if (phead == nullptr || phead->pnext == nullptr)
{
return;
}
else
{
node<T> *p1, *p2,*p3;
p1 = phead;
p2 = p1->pnext;
while (p2!=nullptr)
{
p3 = p2->pnext;
p2->pnext = p1;

p1 = p2;
p2 = p3;
}
phead->pnext = nullptr;
phead= p1;

}
}
//对链表进行排序
template<class T>
void list<T>::sort()
{
cout << "sort" << endl;
if (phead == nullptr || phead->pnext == nullptr)
{
return;
}
else
{
for (node<T> *pt1 = phead;pt1 != nullptr;pt1 = pt1->pnext)
{

for (node<T> *pt2 = pt1->pnext;pt2 != nullptr;pt2 = pt2->pnext)
{
if (pt1->data > pt2->data)
{
pt1->data = pt1->data + pt2->data;
pt2->data= pt1->data - pt2->data;
pt1->data = pt1->data - pt2->data;
continue;
}
}
}
}
}
//获取链表结点个数
template<class T>
int list<T>::getnum()
{
int num = 0;
node<T> *p = phead;
while (p != nullptr)
{
num++;
p = p->pnext;
}
cout << "count=" << num<<endl;
return num;
}
//链表的连接
template<class T>
void list<T>::merge(list<T> &ll)
{
cout << "merge连接" << endl;
node<T> *p=phead;
while (p->pnext!=nullptr)//找到最后一个结点
{
p = p->pnext;
}
p->pnext = ll.phead;

}
#include<iostream>
#include<string>
#include "list.h"
#include "list.cpp"//模板类必须将实体包含，或者生成库
using namespace std;
//链表的实现
void main1()
{
list<int> *l1=new list<int>;
l1->add(22222);
l1->add(1);
l1->add(11);
l1->add(11);
l1->add(111);
l1->add(11);
l1->add(1111);
l1->add(11111);
l1->show();//打印链表数据

list<int> l2;
l2.add(2);
l2.add(3);
l2.add(66666);
l1->merge(l2);
l1->show();

l1->rev();
l1->show();

l1->deletesame();
l1->show();//打印链表数据

l1->sort();
l1->show();//打印链表数据

l1->getnum();

l1->change(l1->find(11), 12);//替换结点数据

l1->deletel(1);//删除

l1->show();//打印链表数据

l1->deleteall();

l1->show();

delete l1;
cin.get();
}
//十字链表
//链表存储的数据链表
void main()
{
list<int> *l1 = new list<int>;
l1->add(22222);
l1->add(1);
l1->add(11);
l1->add(11);
l1->add(111);
//l1->show();//打印链表数据

list<int> *l2=new list<int>;
l2->add(2);
l2->add(3);
l2->add(66666);

list<list<int>*> *l3 = new list<list<int>*>;
l3->add(l1);
l3->add(l2);

l3->phead->data->show();
l3->phead->pnext->data->show();

cin.get();

}


4.哈希存储
容易查找，不易于插入和删除 O(1)

#pragma once

template<class T>
class hashnode
{
public:
int key;//代表索引
T data;//数据
//int count;//查找次数
};
/*
索引
数据
*/
#pragma once
#include "hashnode.h"
#include<string>
using namespace std;
template<class T>
class mhash
{
public:
hashnode<T> *p;///哈希表
int n;//长度
public:
mhash();
~mhash();
int myhash(int data);
void init(T *pt,int nt);
bool isin(int key,T t);
hashnode<T> * find(int key);

};

#include "mhash.h"
#include<string>
using namespace std;

template<class T>
mhash<T>::mhash()
{
this->n = 10;
this->p = new hashnode<T>[this->n];
}

template<class T>
mhash<T>::~mhash()
{
delete[]p;
}
//获得哈希表索引值
template<class T>
int mhash<T>::myhash(int data)
{
return data % n;
}
//哈希表简单初始化
template<class T>
void mhash<T>::init(T *pt,int nt)
{
for (int i = 0;i <10;i++)
{
p[i].key = pt[i]%n;
p[i].data = pt[i];
//p[i].count = 0;
}
}
//判断数据是否存在
template<class T>
bool mhash<T>::isin(int key,T t)
{
if (p[key].data ==t)
{
return true;
}
else
{
return false;
}
}
//查找
template<class T>
hashnode<T> * mhash<T>::find(int data)
{
int res = myhash(data);
return p +res;
}
#include<iostream>
#include "mhash.h"
#include "mhash.cpp"
#include "hashnode.h"

using namespace std;
//哈希表简单原理
void main()
{
mhash<
96fa
int> myh;

int a[10] = {10,11,22,33,44,55,66,77,88,99};

myh.init(a,10);
cout << myh.isin(4,44) << endl;
hashnode<int> *p = myh.find(99);
cout << p->key << endl;
cout << p->data<< endl;

cin.get();
}