当前位置：网站首页>Chapter IX deque of STL

Chapter IX deque of STL

2022-07-19 09:32:00 【qq_ forty-three million two hundred and five thousand two hundr】

1 deque Basic concept of container

function ：

Double ended array , You can insert or delete the header

deque And vector difference ：

vector For the insertion and deletion of the head, the efficiency is low , More data , The less efficient

deque Relatively speaking , The insertion and deletion speed of the head is faster than that of the back vector fast

vector Access to elements is faster than deque fast , This has to do with the internal implementation of both

deque Internal working principle :

deque There's a... Inside The central controller , Maintain the contents of each buffer , The buffer holds real data

The central controller maintains the address of each buffer , Make use of deque It's like a continuous memory space

deque Container iterators also support random access

2 deque Constructors

Function description ：

deque Container construction

The function prototype ：

deque<T> deqT; // Default construction form

deque(beg, end); // The constructor will [beg, end) The elements in the interval are copied to themselves .

deque(n, elem); // The constructor will n individual elem Copy to yourself .

deque(const deque &deq); // copy constructor

Example ：

#include <deque> 
void printDeque(const deque<int>& d) 
{ 
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) 
	{ 
		cout << *it << " "; 
	}
	cout << endl; 
}

//deque structure  
void test01() 
{ 
	deque<int> d1;
	
	//1. Parameter free constructor  
	for (int i = 0; i < 10; i++) 
	{
		d1.push_back(i);
	}
	printDeque(d1); 

	//2. Interval construction 
	deque<int> d2(d1.begin(), d1.end());
	printDeque(d2); 

	//3. Parameter construction 
	deque<int>d3(10, 100); 
	printDeque(d3); 

	//4. Assignment construction 
	deque<int>d4 = d3; 
	printDeque(d4);
}

int main() 
{ 
	test01(); 
	return 0; 
}

summary ：deque Container and vector Containers are constructed in almost the same way , It can be used flexibly

3 deque Assignment operation

Function description ：

to deque Container to assign values

The function prototype ：

deque& operator=(const deque &deq); // Overload the equal sign operator

assign(beg, end); // take [beg, end) The copy of the data in the interval is assigned to itself .

assign(n, elem); // take n individual elem Copy assignment to itself .

Example ：

#include <deque>
void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin();it != d.end(); it++) 
	{
		cout << *it << " ";
	}
	cout << endl;
}

// Assignment operation  
void test01()
{
	deque<int> d1;
	for (int i = 0; i < 10; i++) 
	{ 
		d1.push_back(i); 
	}
	printDeque(d1);


	deque<int>d2;
	d2 = d1; 
	printDeque(d2); 


	deque<int>d3; 
	d3.assign(d1.begin(), d1.end());
	printDeque(d3);


	deque<int>d4; 
	d4.assign(10, 100);
	printDeque(d4);
}

int main() 
{
	test01(); 
	return 0; 
}

summary ：deque The assignment operation is also related to vector identical , Need to master

4 deque Size operation

Function description ：

Yes deque The size of the container

The function prototype ：

deque.empty(); // Judge whether the container is empty

deque.size(); // Returns the number of elements in the container

deque.resize(num); // Reassign the length of the container to num, If the container becomes longer , Then fill in the new location with the default value .

// If the container gets shorter , Then the element beyond the length of the container at the end is deleted .

deque.resize(num, elem); // Reassign the length of the container to num, If the container becomes longer , with elem Value to fill in the new location .

// If the container gets shorter , Then the element beyond the length of the container at the end is deleted .

Example ：

#include <deque>
void printDeque(const deque<int>& d) 
{ 
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) 
	{
		cout << *it << " ";
	}
	cout << endl;
}

// Size operation  
void test01() 
{ 
	deque<int> d1; 
	for (int i = 0; i < 10; i++) 
	{
		d1.push_back(i);
	}
	printDeque(d1); 
	
	// Judge whether the container is empty  
	if (d1.empty()) 
	{
		cout << "d1 It's empty !" << endl;
	}
	else 
	{
		cout << "d1 Not empty !" << endl; 
		// Count the size  
		cout << "d1 The size is ：" << d1.size() << endl; 
	}
	// Re size  
	d1.resize(15);
	printDeque(d1);

	d1.resize(20, 1); 
	printDeque(d1); 

	d1.resize(5); 
	printDeque(d1);
}


int main() 
{ 
	test01();
	return 0;
}

summary ：

deque There is no concept of capacity

Determine whether it is null --- empty

Number of return elements --- size

Reassign the number --- resize

5 deque Insert and delete

Function description ：

towards deque Insert and delete data from containers

The function prototype ：

Two end insertion operation ：

push_back(elem); // Add a data at the end of the container

push_front(elem); // Insert a data in the head of the container

pop_back(); // Delete the last data in the container

pop_front(); // Delete the first data of the container

Specified location operation ：

insert(pos,elem); // stay pos Insert a elem Copies of elements , Returns the location of the new data .

insert(pos,n,elem); // stay pos Position insert n individual elem data , No return value .

insert(pos,beg,end); // stay pos Position insert [beg,end) Interval data , No return value .

clear(); // Empty all the data in the container

erase(beg,end); // Delete [beg,end) Interval data , Return to the next data location .

erase(pos); // Delete pos Location data , Return to the next data location .

Example ：

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) 
	{
		cout << *it << " ";
	}
	cout << endl;
}

// Two end operation  
void test01() 
{ 
	deque<int> d;
	// Tail insertion  
	d.push_back(10); 
	d.push_back(20); 
	
	// Head insertion 
	d.push_front(100); 
	d.push_front(200); 
	printDeque(d);
	
	// Deletion at the end  
	d.pop_back(); 
	printDeque(d);

	// Head deletion  
	d.pop_front(); 
	printDeque(d); 
}


// Insert  
void test02() 
{ 
	deque<int> d; 
	d.push_back(10); 
	d.push_back(20);
	d.push_front(100); 
	d.push_front(200); 
	printDeque(d);

	d.insert(d.begin(), 1000); 
	printDeque(d); 

	d.insert(d.begin(), 2,10000); 
	printDeque(d); 

	deque<int>d2; 
	d2.push_back(1); 
	d2.push_back(2); 
	d2.push_back(3); 
	d.insert(d.begin(), d2.begin(), d2.end()); 
	printDeque(d);
}

// Delete  
void test03() 
{ 
	deque<int> d; 
	d.push_back(10); 
	d.push_back(20);
	d.push_front(100);
	d.push_front(200); 
	printDeque(d);

	d.erase(d.begin()); 
	printDeque(d);

	d.erase(d.begin(), d.end()); 
	printDeque(d);

	d.clear(); 
	printDeque(d); 
}

int main() 
{ 
	test01(); 
	test02(); 
	test03(); 
	return 0; 
}

summary ：

The locations provided by inserts and deletions are iterators ！

Tail insertion --- push_back

Deletion at the end --- pop_back

Head insertion --- push_front

Head deletion --- pop_front

6 deque Data access

Function description ：

Yes deque Access operation of data in

The function prototype ：

at(int idx); // Returns the index idx The data

operator[]; // Returns the index idx The data

front(); // Returns the first data element in the container

back(); // Returns the last data element in the container

Example ：

#include <deque> 
void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) 
	{ 
		cout << *it << " "; 
	}
	cout << endl; 
}

// Data access  
void test01()
{ 
	deque<int> d; 
	d.push_back(10); 
	d.push_back(20);
	d.push_front(100); 
	d.push_front(200);

	//1. Use [] Read 
	for (int i = 0; i < d.size(); i++) 
	{
		cout << d[i] << " "; 
	}
	cout << endl;
	
	//2. Use at Read 
	for (int i = 0; i < d.size(); i++) 
	{ 
		cout << d.at(i) << " "; 
	}
	cout << endl;
	cout << "front:" << d.front() << endl; 
	cout << "back:" << d.back() << endl;
}

int main() 
{ 
	test01(); 
	return 0;
}

summary ：

Except for iterators deque Elements in the container ,[ ] and at It's fine too

front Returns the first element of the container

back Returns the last element of the container

7 deque Sort

Function description ：

The algorithm is used to realize deque Sort the containers

Algorithm ：

sort(iterator beg, iterator end) // Yes beg and end Sort the elements in the interval

Example ：

#include <deque> 
#include <algorithm> 

void printDeque(const deque<int>& d) 
{ 
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{ 
		cout << *it << " "; 
	}
	cout << endl; 
}

void test01() 
{
	deque<int> d; 
	d.push_back(10); 
	d.push_back(20); 
	d.push_front(100);
	d.push_front(200);
	printDeque(d); 
	sort(d.begin(), d.end()); 
	printDeque(d);
}

int main()
{ 
	test01();  
	return 0; 
}

summary ：sort The algorithm is very practical , Include header files when using algorithm that will do

原网站

版权声明
本文为[qq_ forty-three million two hundred and five thousand two hundr]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/200/202207171023057015.html