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

最新推荐文章于 2026-04-06 15:01:32 发布

原创最新推荐文章于 2026-04-06 15:01:32 发布 · 2.7k 阅读

4 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

C++

C++学习总结

本文总结了C++中四种主要的存储结构——顺序存储、链式存储、索引存储和哈希存储的优缺点。顺序存储查找快速但插入删除成本高；索引存储查找效率依赖于索引数量；链式存储适合频繁的增删操作但查找较慢；哈希存储则提供了快速的查找，但增删操作相对复杂。同时，文章还探讨了vector数组、list链表、十字链表、索引结构和hash表的具体实现。

开发板推荐：天空星STM32F407VET6开发板

超高性价比 STM32主控 | 超高主频 | 一板兼容百芯 | 比赛神器 | 沉金彩色丝印

点击查看

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[n] = 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<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();
}

开发板推荐：天空星STM32F407VET6开发板

超高性价比 STM32主控 | 超高主频 | 一板兼容百芯 | 比赛神器 | 沉金彩色丝印

点击查看

标签

#顺序存储，链式存储，索引存储，哈希存储的优缺点，以及vect