程序中会使用数据结构;例如:顺序表、链表、二叉树;
数据结构在底层中本质上只有两种:数据之间挨着和不挨着;
 
1.关于Vector
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAk0AAAAgCAYAAAAPD0z1AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAALBSURBVHhe7dZBiqQrEEXh2tPbU+/prbYaWxLEDK/O4ztwIDWqBn9wBv78AgAA4IpHEwAAwAMeTQAAAA94NAEAADzg0QQAAPCARxMAAMADHk0AAAAPlI+mn58fkiTJdiaOj6Y5YuXYz3///+FB/WT1k9VPVj9Z/WT1k539nCmnosuKLqufrH6y+snqJ6ufrH6ys58z5VR0WdFl9ZPVT1Y/Wf1k9ZPVT3b2c6acii4ruqx+svrJ6iern6x+svrJzn7OlFPRZUWX1U9WP1n9ZPWT1U9WP9nZz5lyKrqs6LL6yeone+pHV9O1n/F7d91lR8cOqp3t7n/TxfHt1d44nW2cKaedg3pRdFn9ZPWTPfWjq+nez+3czb2Tqpvqrovd+7g52zhTTjsH9aLosvrJ6id76mfca+u7n9u5m3sjVTPVXRe793FztnGmnHYO6kXRZfWT1U+26udzp63vfm7nbq6N6OXb7n3cnM2cKadCy4ouq5+sfrJVP587bX33M86r66yjYwfrrtbdUSM3ZzNnyqnQsqLL6iern2zVz3rXva+9n9u5m1rJdu/j5mzmTDkVWlZ0Wf1k9ZOt+hl3q/u8k+P7932t59NdF9c+urdS2bmNF2czZ8qp0LKiy+onq5/s3s/t3M29n6qn6q6Lax/dW6ns3MaLs5kz5VRoWdFl9ZPVT3bvp+qpc2N7P1VP1V0X9zaqVqq7LnZu48XZxply2jmoF0WX1U9WP9m9n6qnzo3t/dzO3dzbuJ272b2Pm7OPM+W0e1Q3RZfVT1Y/2bWf8ftjuuvk+O51V7vrLjs6dlDt7OM+66ZGsrORM+VUWFnRZfWT1U9WP1n9ZPWT1U929nOmnIouK7qsfrL6yeonq5+sfrL6yc5+zpTT8U8kSZLdTOQpAAAA/uHRBAAA8IBHEwAAwAMeTQAAAA94NAEAAFz5/f0LednWsiXa3JwAAAAASUVORK5CYII=" alt="" />
    1】本质就是一个数组            
    2】可以动态扩充容量            
    3】支持下标方法,查询性能好            
    4】新增数据和删除数据较差   
        比如在A和B之间插入一个元素,B后面的所有数据都要后移
 
2.实现Vector
ArrayList.h
#ifndef ARRYALIST_H
#define ARRYALIST_H #define VSUCCESS 1 // 成功
#define VERROR -1 // 失败
#define MALLOC_ERROR -2 // 申请内存失败
#define INDEX_ERROR -3 // 错误的索引号 #include "stdio.h"
#include <stdlib.h>
#include <windows.h> template <class T_ELE>
class Vector
{
public:
Vector();
Vector(DWORD dwSize);
~Vector();
public:
DWORD at(DWORD dwIndex,OUT T_ELE* pEle); //根据给定的索引得到元素
DWORD push_back(T_ELE Element); //将元素存储到容器最后一个位置
VOID pop_back(); //删除最后一个元素
DWORD insert(DWORD dwIndex, T_ELE Element); //向指定位置新增一个元素
DWORD capacity(); //返回在不增容的情况下,还能存储多少元素
VOID clear(); //清空所有元素
BOOL empty(); //判断Vector是否为空 返回true时为空
VOID erase(DWORD dwIndex); //删除指定元素
DWORD size(); //返回Vector元素数量的大小
private:
BOOL expand();
private:
DWORD m_dwIndex; //下一个可用索引
DWORD m_dwIncrement; //每次增容的大小
DWORD m_dwLen; //当前容器的长度
DWORD m_dwInitSize; //默认初始化大小
T_ELE *m_pVector; //容器指针
}; //********无参构造**********
template <class T_ELE>
Vector<T_ELE>::Vector()
:m_dwInitSize(),m_dwIncrement()
{
//1.创建长度为m_dwInitSize个T_ELE对象
m_pVector = new T_ELE[m_dwInitSize]; //2.将新创建的空间初始化
memset(m_pVector, , sizeof(T_ELE)*m_dwInitSize); //3.设置其他值
m_dwIndex = ;
m_dwLen = m_dwInitSize;
} //************有参构造*************
template <class T_ELE>
Vector<T_ELE>::Vector(DWORD dwSize)
:m_dwIncrement()
{
//1.创建长度为dwSize个T_ELE对象
m_pVector = new T_ELE[dwSize];
if(!m_pVector){
return;
} //2.将新创建的空间初始化
memset(m_pVector, , sizeof(T_ELE)*dwSize); //3.设置其他值
m_dwIndex = ;
m_dwLen = dwSize; } //************析构函数*************
template <class T_ELE>
Vector<T_ELE>::~Vector()
{
//释放空间 delete[]
delete[] m_pVector; } //************扩容*************
template <class T_ELE>
BOOL Vector<T_ELE>::expand()
{
// 1. 计算增加后的长度
DWORD size = m_dwLen + m_dwIncrement;
printf("数组容量%d不够,扩容为%d\n", m_dwLen, size);
// 2. 申请空间
T_ELE* newArr = new T_ELE[size];
if(!newArr){
return FALSE;
} // 3. 将数据复制到新的空间
memset(newArr, , sizeof(T_ELE)*size);
memcpy(newArr, m_pVector, sizeof(T_ELE)*m_dwLen); // 4. 释放原来空间
delete[] m_pVector;
m_pVector = newArr;
newArr = NULL; // 5. 为各种属性赋值
m_dwLen = size; return TRUE;
} //************末尾添加*************
template <class T_ELE>
DWORD Vector<T_ELE>::push_back(T_ELE Element)
{
//1.判断是否需要增容,如果需要就调用增容的函数
if(m_dwIndex >= m_dwLen){
expand();
} //2.将新的元素复制到容器的最后一个位置
m_pVector[m_dwIndex] = Element; //3.修改属性值
m_dwIndex++;
return VSUCCESS;
} //************中间插入*************
template <class T_ELE>
DWORD Vector<T_ELE>::insert(DWORD dwIndex, T_ELE Element)
{
//1.判断是否需要增容,如果需要就调用增容的函数
if(m_dwIndex >= m_dwLen){
expand();
} //2.判断索引是否在合理区间
if(dwIndex< || dwIndex>m_dwIndex){
return INDEX_ERROR;
} //3.将dwIndex只后的元素后移
for(int i=m_dwIndex;i>dwIndex;i--){
memcpy(m_pVector+i, m_pVector+i-, sizeof(T_ELE));
} //4.将Element元素复制到dwIndex位置
memcpy(m_pVector+dwIndex, &Element, sizeof(T_ELE)); //5.修改属性值
m_dwIndex++;
return VSUCCESS;
} //************下标获取*************
template <class T_ELE>
DWORD Vector<T_ELE>::at(DWORD dwIndex,T_ELE* pEle)
{
//判断索引是否在合理区间
if(dwIndex< || dwIndex>=m_dwIndex){
return INDEX_ERROR;
} //将dwIndex的值复制到pEle指定的内存
memcpy(pEle, m_pVector+dwIndex, sizeof(T_ELE));
return VSUCCESS;
} //********末尾删除***********
template <class T_ELE>
VOID Vector<T_ELE>::pop_back(){
//判断是否还有
if(m_dwLen <=){
printf("一个元素都没有了\n");
return;
}
//删除
m_dwIndex--;
memset(m_pVector+m_dwIndex, , sizeof(T_ELE));
} //********不增容剩余容量********
template <class T_ELE>
DWORD Vector<T_ELE>::capacity(){
return m_dwLen - m_dwIndex;
} //*********清空容器*******
template <class T_ELE>
VOID Vector<T_ELE>::clear(){
memset(m_pVector, , sizeof(T_ELE)*(m_dwIndex + ));
//修改属性值
m_dwIndex = ;
} //**********判断容器是否为空******
template <class T_ELE>
BOOL Vector<T_ELE>::empty(){
if(m_pVector){
return TRUE;
}else{
return FALSE;
}
} //*********删除指定元素********
template <class T_ELE>
VOID Vector<T_ELE>::erase(DWORD dwIndex){
//判断下标是否在有效区间
if(dwIndex< || dwIndex >m_dwIndex){
printf("下标越界了\n");
return;
}
//删除
for(int i=dwIndex;i<m_dwIndex;i++){
memcpy(m_pVector+i,m_pVector+i+, sizeof(T_ELE));
}
m_dwIndex--;
memset(m_pVector+m_dwIndex, , sizeof(T_ELE)); } //********返回元素数量*******
template <class T_ELE>
DWORD Vector<T_ELE>::size(){
return m_dwIndex;
} #endif
测试:
#include "ArrayList.h"

template <class T_ELE>
void printVector(Vector<T_ELE>* list){
for(int i=;i<list->size();i++){
T_ELE k;
list->at(i,&k);
printf("%d\t",k);
}
printf("\n");
} void main(){
Vector<int>* list = new Vector<int>(); list->push_back();
list->push_back();
list->push_back();
list->push_back();
printVector(list);
printf("元素个数:%d,容量还剩%d\n",list->size(),list->capacity()); list->insert(,);
printVector(list);
printf("元素个数:%d,容量还剩%d\n",list->size(),list->capacity()); list->push_back();
list->push_back();
list->push_back();
printVector(list);
printf("元素个数:%d,容量还剩%d\n",list->size(),list->capacity()); list->pop_back();
list->erase();
printVector(list);
printf("元素个数:%d,容量还剩%d\n",list->size(),list->capacity()); list->clear();
printVector(list);
printf("元素个数:%d,容量还剩%d\n",list->size(),list->capacity()); getchar();
}
结果:
aaarticlea/png;base64,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" alt="" />
 
遇到的坑:
    本来想将vector的头文件和实现分开的,结果分开后编译出错,说头文件的函数没实现;
    可能是用了模板的原因,也不清楚,浪费时间在不太重要的地方不划算,总之不分开就好了;
 
 
 
 

顺序表Vector的更多相关文章

  1. C++的标准模板库STL中实现的数据结构之顺序表vector的分析与使用

    摘要 本文主要借助对C++的标准模板库STL中实现的数据结构的学习和使用来加深对数据结构的理解.即联系数据结构的理论分析和详细的应用实现(STL),本文是系列总结的第一篇,主要针对线性表中的顺序表(动 ...

  2. C++实现动态顺序表

    顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构.这样的存储方式使得线性表逻辑上相邻的元素,其在物理存储单元中也是相邻的.只要知道了第一个元素的存 ...

  3. C++模板实现动态顺序表(更深层次的深浅拷贝)与基于顺序表的简单栈的实现

    前面介绍的模板有关知识大部分都是用顺序表来举例的,现在我们就专门用模板来实现顺序表,其中的很多操作都和之前没有多大区别,只是有几个比较重要的知识点需要做专门的详解. #pragma once #inc ...

  4. C++数据结构学习之顺序表

    顺序表是数据结构中最基本也是应用相当广泛的一种数据结构类型.它通常包含三个私有成分,即指向数据数组的头指针.当前表长以及表的实际容量.表的头指针通常指向数据数组的基地址,通过数组的形式进行访问数据数组 ...

  5. [Java算法分析与设计]--线性结构与顺序表(List)的实现应用

    说到线性结构,我们应该立马能够在脑子里蹦出"Array数组"这个词.在Java当中,数组和对象区别基本数据类型存放在堆当中.它是一连串同类型数据存放的一个整体.通常我们定义的方式为 ...

  6. C++语言------顺序表实现,用动态数组的方法

    C++ 中常用的一些东西,通过使用动态数组来实现顺序表, 掌握了一下知识点: 1.预处理有三中方法 宏定义,文件包含,条件编译 2.使用同名的变量时,可以在外层使用命名空间 类解决变量名重定义的错误 ...

  7. 第十篇:顺序容器vector,deque,list的选用规则

    前言 常见的顺序容器主要有三种 - vector,deque,list.它们实现的功能相差不大,那么实际开发中该如何进行选择呢?本文将为你解答这个问题. 分析 由于这三种容器实现的数据结构原型不同(v ...

  8. 数据结构与算法之顺序表C语言实现

    顺序表等相关概念请自行查阅资料,这里主要是实现. 注: 1.顺序表C语言实现: 2.按较简单的方式实现,主要帮助理解,可在此基础上修改,更加完善: 3.提供几个简单函数,可自行添加功能: 4.可用C+ ...

  9. 顺序容器vector,deque,list的选用规则

    前言 常见的顺序容器主要有三种 - vector,deque,list.它们实现的功能相差不大,那么实际开发中该如何进行选择呢?本文将为你解答这个问题. 分析 由于这三种容器实现的数据结构原型不同(v ...

随机推荐

  1. 通过JAX-WS实现WebService

    (一)服务端的创建 一,首先创建一个Web 项目,或者创建一个Web Service项目也行(差别就是后者在开始就设置了Web Service的调用方式) 二,在项目中创建一个类作为我们要发布的服务( ...

  2. redis 持久化 ——RDB

    文章目录 RDB 关于 fork dump.rdb 文件 如何触发 RDB 快照 如何恢复 优势 劣势 停掉 RDB RDB redis database 的简写 : 在指定时间间隔后,将内存中的数据 ...

  3. JS 04 Date_Math_String_Object

    Date <script> //1.Date对象 var d1 = new Date(); //Thu May 02 2019 14:27:19 GMT+0800 (中国标准时间) con ...

  4. asp.net core-5.控制台读取json文件

    1,创建控制台应用程序,应用using Microsoft.Extensions.Configuration; 2,新建一个app.json文件 然后修改app.json的属性 3,生成项目,可以看到 ...

  5. Docker相关环境全套安装文档兼小技能

    Docker相关环境全套安装文档兼小技能 以下环境皆为ubuntu16.04,主要安装docker,docker-compose,docker仓库等. Docker安装 参考官方 A: 有源安装 Ub ...

  6. Unity性能优化-DrawCall

    1. DrawCall是啥?其实就是对底层图形程序(比如:OpenGL ES)接口的调用,以在屏幕上画出东西.所以,是谁去调用这些接口呢?CPU.比如有上千个物体,每一个的渲染都需要去调用一次底层接口 ...

  7. poj 3069 继续弱鸡的贪心

    题意:给出指路石的范围,问最小需要几个指路石可以覆盖所有的军队. 题解:排序一遍,然后扫出起始区间和终止区间,就可以求出最小的覆盖数了 ac代码: #include <iostream> ...

  8. MySql外网不能访问设置

    mysql的root账户,我在连接时通常用的是localhost或127.0.0.1,公司的测试服务器上的mysql也是localhost所以我想访问无法访问,测试暂停. 解决方法如下: 1,修改表, ...

  9. CentOS 系统 MySQL 5.7 开启远程连接

    CentOS 系统安装好 MySQL 后,默认情况下不支持用户通过非本机连接上数据库服务器,下面是解决方法: 1.在控制台执行 mysql -u root -p 系统提示输入数据库 root 用户的密 ...

  10. spring.factories配置文件的工厂模式

    在springboot的各个依赖包下,我们经常看到META-INF/spring.factories这个文件.spring.factories文件的内容基本上都是这样的格式: # Initialize ...