顺序容器相关内容总结

最新推荐文章于 2024-10-17 17:19:00 发布
最新推荐文章于 2024-10-17 17:19:00 发布
阅读量497 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： null list insert vector 存储 iterator
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luckyitman/article/details/7908266
版权

本文就数组、链表、队列、栈（顺序容器）进行常识性的介绍和总结，文章先分别介绍各部分知识点，最后进行对比总结。

          一、 数组

        用C和C++实现数组的方式是有区别的；

       C通过：类型 数组名【数组大小】 显示定义数组的类型和大小，并且根据内置类型初始化规则进行初始化.比如int a[10]定义a是含有10个元素的整型数组，int默认初始化为0.用C实现的数组大小不能动态实现，如果在实际应用中数组容量不够，必须通过定义一个更大的数组将初始数组复制过去，再将小的数组删除，（通过malloc()和free()函数进行内存的分配和释放）因此在使用时通常将数组定义成足够大，所以会存在内存空间浪费的现象。

       C++通过：STL标准库vector来实现，以vector 定义数组，可以指定数组的类型，根据type的类型来选择是利用内置类型、符合类型或提供了默认构造函数的类类型来进行初始化，vector容器有容量和长度之分，通常容量>长度，并且可以根据vecotor类的接口函数进行复制、赋值、访问、重新设定数组大小等操作，数组的大小可以动态实现。(通过new和delete操作符进行内存的分配和释放)。由于数组在内存当中是连续存储的，因此可以利用下标进行索引，随机访问很方便。

       测试程序：

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

int main()
{
	int a[10]={1,2,3};
	cout<<"数组a:"<<endl;
	for(int i=0;i<10;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	vector<int> b(10);//b(10)初始化前10个元素为0
	b.push_back(1);
	b.push_back(2);
	b.push_back(3);
	cout<<"数组b的长度："<<b.size()<<endl;
	cout<<"数组b的容量："<<b.capacity()<<endl;
	cout<<"数组b:"<<endl;
	for(vector<int>::iterator iter=b.begin();iter != b.end();iter++)
		cout<<*iter<<" ";
	cout<<endl;
	system("pause");
	return 0;
}

         二、 链表


         数组实现了数据的顺序存储，便于元素的随机访问，但是不利于删除和插入元素，并且容易造成内存空间的浪费，链表解决数组的这些缺点，内存空间利用率高，并且易于删除和插入，但是不利于随机访问，只能通过遍历链表来实现随机访问，效率不高。C++使用STL中的List类定义的方法来实现链表的各项操作。
链表从逻辑结构上分为单向链表和双向链表和循环链表。
        下面结合《程序员面试宝典-3》中的相关例题进行链表分析：

    1.单链表：实现单链表的建立、测长、打印、插入、删除、排序功能。

//实现单链表的建立、测长、打印、插入、删除、排序、逆置功能。

#include <iostream>
using namespace std;

typedef struct student
{
	int data;
	struct student *next;
}node;

//链表的建立
node *creat()
{
	node *head,*p,*s;//head用来做返回值，p创建链表的移动指针，s用于添加元素时创建结点
	head= new node;
	p=head;
	int x;
	int cycle=1;//用户判定是否继续输入，0停止建立链表
	while(cycle)
	{
		cout<<"please input the data:"<<endl;
		cin>>x;
		if(x!=0)
		{
			s=new node;
			s->data=x;
			p->next=s;
			p=s;
		}
		else cycle=0;
	}
	head=head->next;
	p->next=NULL;
	return head;
}

//链表的测长
int length(node *head)
{
	int n=0;
	node *p=head;
	while(p!=NULL)
	{
		p=p->next;
		n++;
	}
	return n;
}

//链表的打印
void print(node *head)
{
	node *p=head;
	while(p!=NULL)
	{
		cout<<p->data<<" ";
		p=p->next;
	}
	cout<<endl;
}

//链表的插入
node *insert(node *head,int num)
{
	node *p0=new node;
	node *p1=head;
	node *p2;
	p0->data=num;
	if(p0->data<=head->data)
	{
		p0->next=p1;
		head=p0;
	}
	else //if(p0->data>head->data)
	{
		while(p0->data>p1->data && p1->next !=NULL)
		{
			p2=p1;
			p1=p1->next;
		}
		if(p1->next !=NULL || p0->data <=p1->data ) //还没到末尾
		{
			p2->next=p0;
			p0->next=p1;
		}
		else //末尾
		{
			p1->next=p0;
			p0->next=NULL;
		}
	}
	return head;
}

//链表的删除
node *del(node *head,int num)
{
	node *p1=head;
	node *p2;
	if(num==p1->data)
	{
		head=p1->next;
		delete p1;
	}
	else
	{
		while(num!=p1->data && p1->next !=NULL)
		{
			p2=p1;
			p1=p1->next;
		}
		if(num==p1->data )
		{
			p2->next=p1->next;
			delete p1;
		}
		else 
			cout<<"该链表没有元素："<<num<<endl;
	}
	return head;
}

//链表的排序
node *sort(node *head)
{
	node *p0;
	int n=length(head);
	int temp;
	if(head==NULL || head->next==NULL)
		return head;
	p0=head;
	for(int i=1;i<n;i++)
	{
		p0=head;
		for(int j=0;j<n-i;j++)
		{
			if(p0->data>p0->next->data)
			{
				temp=p0->next->data;
				p0->next->data=p0->data;
				p0->data=temp;
			}
			p0=p0->next;
		}
	}
	return head;
}

//链表的逆置
node *reverse(node *head)
{
	node *p1,*p2,*p3;
	if(head==NULL || head->next==NULL)
		return head;
	p1=head,p2=p1->next;
	while(p2)
	{
		p3=p2->next;
		p2->next=p1;
		p1=p2;
		p2=p3;
	}
	head->next=NULL;
	head=p1;
	return head;
}

int main()
{
	node *list;
	int leng;
	cout<<"建立链表："<<endl;
	list=creat();
	list=insert(list,4);
	list=del(list,1);
	leng=length(list);
	cout<<"建立的链表长度为："<<leng<<endl;
	cout<<"打印链表："<<endl;
	print(list);
	sort(list);
	cout<<"排序后打印链表："<<endl;
	print(list);
	list=reverse(list);
	cout<<"逆置后打印链表："<<endl;
	print(list);
	system("pause");
	return 0;
}

      

        2.双链表：建立、测长、打印、删除、插入

 

//实现双向链表的建立、删除和插入

#include <iostream>
using namespace std;

typedef struct student
{
	int data;
	struct student *next;
	struct student *prev;
}dnode;

//建立链表
dnode *creat()
{
	dnode *head,*p,*s;
	int x,cycle=1;
	head=new dnode;
	p=head;
	while(cycle)
	{
		cout<<"please enter the data:";
		cin>>x;
		//cout<<endl;
		if(x!=0)
		{
			s=new dnode;
			s->data=x;
			p->next=s;
			s->prev=p;
			p=s;
		}
		else
			cycle=0;
	}
	p->next=NULL;
	head=head->next;
	head->prev=NULL;
	return head;
}

//链表测长
int length(dnode *head)
{
	int n=0;
	dnode *p=head;
	while(p!=NULL)
	{
		p=p->next;
		n++;
	}
	return n;
}

//链表的打印
void print(dnode *head)
{
	dnode *p=head;
	while(p!=NULL)
	{
		cout<<p->data<<" ";
		p=p->next;
	}
	cout<<endl;
}

//删除链表结点
dnode *del(dnode *head,int num)
{
	dnode *p=head;
	while(num !=p->data && p->next !=NULL)
	{
		p=p->next;
	}

	if(num==p->data)
	{
		if(p==head)
		{
			head=head->next;
			head->prev=NULL;
			delete p;
		}
		else if(p->next==NULL)
		{
			p->prev->next=NULL;
			delete p;
		}
		else
		{
			p->prev->next=p->next;
			p->next->prev=p->prev;
			delete p;
		}
	}
	else
		cout<<"该链表中没有要删除的元素："<<endl;
	return head;
}

//插入链表结点
dnode *insert(dnode *head,int num)
{
	dnode *p=head,*s;
	s=new dnode;
	s->data=num;
	while(num>p->data && p->next !=NULL)
	{
		p=p->next;
	}
	if(num<=p->data)
	{
		if(p==head)
		{
			p->prev=s;
			s->next=p;
			head=s;
		}
		else
		{
			p->prev->next=s;
			s->next=p;
			s->prev=p->prev;
			p->prev=s;
		}
	}
	else
	{
		p->next=s;
		s->prev=p;
		s->next=NULL;
	}
	return head;
}


int main()
{
	dnode *dlist;
	int leng;
	dlist=creat();
	leng=length(dlist);
	cout<<"链表长度为:"<<leng<<endl;
	cout<<"打印链表："<<endl;
	print(dlist);
	dlist=del(dlist,4);
	cout<<"删除元素后打印链表："<<endl;
	print(dlist);
	dlist=insert(dlist,5);
	cout<<"插入元素后打印链表："<<endl;
	print(dlist);
	//cout<<""<<endl;
	system("pause");
	return 0;
}


          3.循环链表不做详细介绍。

          三、 数组与链表的区别
         1.从逻辑结构上看：数组必须预先定义好固定的长度大小，不能动态改变内存大小，当数据增加超过数组容量时必须重新定义一个更大的数组，并将原始数组复制过去，当数据减小时，数组大小并不会减小，因此数组的内存利用率低且不灵活。链表能通过new和delete等操作符动态进行分配内存，且很方便的插入和删除数据项。
        2.从内存存储看：数组从栈中分配空间，因此空间的分配和回收由编译器完成，程序员方便，但自由度小。链表从堆中分配空间，空间的分配和释放必须由程序员管理。
        3.从访问方式看：数组是顺序连续存储，可以利用下标进行访问，随机访问很方便，但是插入删除工作量很大。链表是链式存储结构，便于插入删除，但是访问效率比数组低。

        四、 队列
        先进先出FIFO，主要用于文件服务器，排队理论。

       五、 栈
      是后进先出LIFO表，主要用在平衡符号，后缀表达式，函数调用，中缀到后缀的转变等方面。
 

好人大海
关注
专栏目录
C++STL容器内容总结
大秦坑王的专栏
03-29 5062
C++ STL容器使用，原理剖析总结 目录 如果需要录屏资料，请私信邮箱shitou3000@qq.com获取。 ...
C++ 顺序容器基础知识总结
12-31
C++中的顺序容器是STL（标准模板库）的一部分，用于存储元素序列。它们是模板类，因此能够存储任何类型的对象。顺序容器根据元素的存储和访问方式可以进一步分类为序列容器和关联容器。序列容器包括vector、list、...
容器的归纳和总结系列片之一
专栏
01-14 789
1、什么是容器？ 在程序中，容器是一种用来容纳对象的数据结构，比如说list、set 、map、queue。 2、为什么需要容器？ 我们为什么需要容器呢？因为在程序中，我们会在任意时刻和任意位置创建任意数量的对象。没有容器，我们能够坐到在任意时刻和任 意位置创建对象，但是创建任意数量的对象却是做不到。有人说我们有数组呀，但是数组的大小是不能改变的呀。所以迫于这种任意数 量
Java容器归纳总结
qq_41174706的博客
03-28 146
Java容器归纳总结 以JavaGuide为主线参考，结合Oracle官方文档和本人刷题过程中的经验进行的一些总结归纳，如果有疑问或者建议欢迎指出 集合（Collection） List, Set, Map三者区别： List: 有序存储数据，可重复（处理有序问题） Set: 无序存储数据，不可重复 （处理查重问题） Map: 使用键值对(Key-Value)存储，Key是无序的、不可重复的；Value是无序的、可重复的，每个Key最多映射到一个Value（处理用Key来搜索的问题）p.s. 数组就是一个简
Java 容器相关知识全面总结
Flyer的后花园
09-01 4107
Java实用类库提供了一套相当完整的容器来帮助我们解决很多具体问题。因为我本身是一名Android开发者，包括我在内很多安卓开发，最拿手的就是ListView(RecycleView)+BaseAdapter+ArrayList三剑客, 平时接触使用的容器也只有ArrayList和HashMap。导致对于整个Java容器体系的掌握和使用还停留在很浅的层面。省不足而思改进，那么跟着我来总结一下Jav
顺序容器总结
szplzx1314的博客
10-02 109
顺序容器 C++标准模板库提供三种 vector,list,deque,其中vector和deque是数组,list是双向链表. 向量(vector) 一个动态容的顺序容器,连续的存储地址,可以通过[]来直接访问任意元素. 相比list和deque,可以更快的索引,可以在尾部快速的删除和插入 列表(list) 一个双向链表,相对vector的联系空间,list复杂很多,它可以快速的插入和删除,但是随机访问比较慢. 因为是链表实现,所以他不会造成空间浪费. 双端队列(deque) dequ
C++_顺序容器
菜鸡逆袭的博客
08-28 350
顺序容器类型 顺序容器 vector: 支持快速随机访问 list: 支持快速插入与删除 deque: 双端队列 顺序适配器 - stack: 后进先出(LIFO)堆栈 - queue: 先进先出(FIFO)队列 - priority_queue: 有优先级管理的队列 上述顺序容器包含于以下头文件中:&lt; vector &gt;,&lt; list &gt;,&lt; ...
【学习笔记】顺序容器的表格方式总结 C++
码的世界
12-09 740
更新中…
C++ | STL标准库之顺序容器
weixin_44742670的博客
12-16 1549
前言 STL六大组件中的容器按照结构特征可分为顺序容器（链状）、关联式容器（树状）和无序式容器。本文就其中顺序容器进行总结和介绍。 一、顺序容器概述 标准库顺序容器有：vector、deque、list、forward_list、arry、string。六个顺序容器中，只有arry是固定大小。 vector： string和vector将元素保存在连续的内存空间中，因此由下标计算其地址很方便。但因为其连续的特性，在其中间位置添加或删除元素非常耗时，这可能会移动变动位置之后的所有元素。 注： vect
C++顺序容器总结
草帽小子的博客
04-12 269
顺序容器介绍 vector 可变大小数组。支持快速随机访问。在尾部之外的位置插入或者删除元素可能很慢。 deque 双端队列。支持快速随机访问。在头尾位置插入或者删除速度很快。 list 双向链表。只支持双向顺序访问。在list中任何位置进行插入或者删除速度都很快。 forward_list 单向链表。只能支持单向顺序访问。在链表任何位置进行插入或者删除操...
STL--顺序容器的总结
wo17fang的专栏
05-25 416
（注：本文转载自http://blog.csdn.net/hackbuteer1/article/details/6791260） 本文主要讨论C++标准库中的顺序容器及相应的容器适配器，这些内容主要涉及顺序容器类型：vector、list、deque，顺序容器适配器类型：stack、queue、priority_queue。 标准库中的容器分为顺序容器和关联容器。顺序容器(seq
C++ Premier顺序容器思维导图总结
05-24
附件的内容为使用思维导图XMind总结C++标准库的顺序容器，通过把C++ Premier顺序容器翔实的放在一张图片上，可以非常方便的梳理思路，在工作中也能提高工作效率。灵活的使用容器是C++开发人员必须具备的技能
c++中容器之总结篇
12-31
C++中的容器大致可以分为两个大类：顺序容器和关联容器。顺序容器中有包含有顺序容器适配器。 顺序容器：将单一类型元素聚集起来成为容器，然后根据位置来存储和访问这些元素。主要有vector、list、deque（双端队列...
java容器类知识点详细总结
08-25
Java 容器类知识点详细总结 Java 容器类是 Java 语言中的一种非常重要的数据结构，用于存储和管理对象的集合。Java 容器类可以分为四个主要部分：Collection、Map、Iterator 和子接口。 容器接口 容器接口是 Java...
list和vector的区别
2303_76580416的博客
10-15 354
deque删除的时候不会导致迭代器失效（非迭代器位置），插入会导致迭代器失效。4>list内部排序是指针指向的更改，vector涉及对象的创建和销毁。list删除元素导致当前迭代器失效，不影响其他迭代器。list节点不连续，容易造成内部碎片，空间利用率低。3>list是双向迭代器，vector是随机迭代器。2>list删除元素会释放空间，vector不会。7>vector连续空间，不容易产生内部碎片。5>vector改变元素，导致迭代器失效。6>vector是连续存储容器，动态数组。
ListView
最新发布
Kodulf的专栏
10-17 313
以上三种方法都可以在Android中使用ListView，你可以根据你的具体需求选择合适的方法。ArrayAdapter是最简单的适配器，它将字符串数组的内容显示在ListView中。SimpleAdapter可以用于将更复杂的数据绑定到ListView。如果你需要更复杂的布局或行为，你可以创建自定义的Adapter。在Android中，有三种简单的方法可以使用ListView。使用SimpleAdapter。使用ArrayAdapter。使用自定义Adapter。
Dart的List和Map类型
Python私教
10-14 1426
可以把它看作一个现实世界的字典，其中每个单词(键)都有相应的定义(值)。列表是零索引的，所以你可以使用它们的索引访问单个项目，比如’ shoppingList[0] ‘，它将返回’ Apples '。无论您是在处理购物清单、待办事项清单还是需要分组的任何其他类型的数据，Dart列表都将证明是您编程过程中必不可少的工具。它们提供了一种灵活的方式来组织信息，使它们成为各种应用程序(从简单的数据管理到复杂的数据结构)的基本工具。列表是动态的，这意味着它们的大小可以改变，并且它们可以存储不同数据类型的元素。
集合框架07：LinkedList使用
zhangjinajian759的博客
10-13 607
13.14 LinkedList使用_哔哩哔哩_bilibili。2.LinkedList集合的增删改查操作。
Collection 单列集合 List Set
saber的博客
10-16 757
介绍了Java集合框架的基础知识，重点讲解了Collection和Map两种主要的集合类型以及它们的子接口（如List和Set）和实现类（例如ArrayList和HashSet）。文章详细阐述了单列集合（Collection）和双列集合（Map）的特点、用途及其操作方法。特别指出了集合框架中的核心接口（如List、Set）及其常见实现类的功能与用法，并通过示例代码展示了如何使用这些集合类型进行数据的存储、遍历以及修改
C++容器详解：顺序与关联容器
本文将对C++的顺序容器和关联容器进行详细总结，包括它们的基本概念、定义、初始化方法以及指针运算等方面的知识点。" 在C++中，容器是标准模板库(STL)的一部分，它们提供了数据结构和算法的抽象，极大地提高了编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值