lists stl
Запознайте се с всички списъци в STL заедно с тяхното прилагане.
Списъците са последователни контейнери. Списъците съдържат елементи на несъседни места. Обсъждахме масиви и вектори в предишните ни уроци.
В случай на масив и векторни контейнери, тъй като тези контейнери съхраняват данни в непрекъсната памет, операцията за вмъкване в средата на тези контейнери се оказва много скъпа, тъй като трябва да изместим съответно съществуващите елементи, за да освободим място за новия елемент.
=> Вижте тук, за да разгледате пълния списък с уроци за C ++.
Какво ще научите:
каква е разликата между c ++ и java
Общ преглед
Списъкът е контейнер, който преодолява този недостатък на масивите и векторните контейнери. Позволява ни да вмъкваме елементи навсякъде в списъка, без да причиняваме големи разходи. Но списъците са по-бавни от векторите, що се отнася до обръщането.
В този урок ще видим прилагането на списъци в STL заедно с различните операции на обхождане, манипулации и достъп до списък с примери.
Имайте предвид, че по-голямата част от операциите със списъци са подобни на тези на векторите и следователно читателите, които вече са прочели нашия урок за вектори, няма да имат проблеми при интерпретирането на концепциите на списъка.
Декларация и инициализация
За да приложим списъчен контейнер и да използваме всички негови предимства, трябва да включим заглавен файл в нашата програма.
#include Общата декларация за списъчен контейнер е
std::list listName; Например,можем да декларираме списък с име ‘mylist’ от тип int, както следва:
std::list mylist; Също така можем да инициализираме списъка по време на декларацията или да добавим елементи към него, като използваме една от операциите, които той поддържа.
Нека да видим как можем да инициализираме списъка, който създадохме по-горе.
std::list mylist = {1, 1, 2, 3, 5}; Горната инициализация ще бъде заложена в паметта, както е показано по-долу:
След като инициализираме списъка, можем да осъществим достъп до елементите на списък с помощта на итератор. Функциите „Итератор“ „начало“ и „край“ ни помагат да преминем през елементите на списъка.
Забележка: Итераторът за списъка поддържа и други итератори като обратни итератори (rbegin, rend), константни итератори (cbegin, cend) и постоянни обратни итератори (crbegin, crend) и може да се използва по подобен начин като вектори.
Следващият пример показва това.
#include #include #include #include using namespace std; int main() { list mylist = {1, 1, 2, 3, 5}; cout<<”List elements are: “; list::iterator it; for(it=mylist.begin();it!=mylist.end();++it) cout<<*it<<” “; }Изход:
Елементите на списъка са: 1 1 2 3 5
По този начин в горния пример ние декларирахме списък на последователността на Фибоначи. След това декларираме итератор от същия тип като list и след това, използвайки for цикъл, отпечатваме съдържанието на списъка от началото до края.
Сега нека да преминем към операциите или функциите, които списъчният контейнер в STL ни предоставя.
Списък на операциите
- Вмъкване: Използва се за вмъкване на елемент в дадената позиция. Връща итератор, сочещ към първия вмъкнат елемент.
вмъкване (pos, num_elem, elem)
Където,
поз => Позиция, на която трябва да се вмъкнат нови елементи.
num_elem => Брой елементи за вмъкване; по подразбиране е 1.
артикул => Действителна стойност, която трябва да се вмъкне.
Нека разберем функцията за вмъкване, като вземем пример.
#include #include // for list operations using namespace std; int main() { list mylist = {1,1,2}; list::iterator it = mylist.begin(); // iterator to point to 4th position advance(it,` 3); // inserts 3 at 4th position mylist.insert(it, 3); cout << 'The list after inserting' << ' 1 element using insert() is : '; for (list::iterator i = mylist.begin();i != mylist.end();i++) cout << *i << ' '; cout << endl; }Изход:
Списъкът след вмъкване на 1 елемент с помощта на insert () е: 1 1 2 3
Това е пример за вмъкване само на един елемент в 4типозиция в списъка, която в крайна сметка е последната позиция. Следователно, първо, имаме списък, за който сме определили итератора, сочещ към началото на списъка. След това преместваме този итератор на 4типозиция и след това извикайте insert, за да вмъкнете 1 елемент.
Също така можем да вмъкнем повече от един елемент, като посочим втория параметър във функцията за вмъкване. Винаги, когато не е посочено, по подразбиране е 1.
- избутвам :Добавя нов елемент в края на списъка.
- push_front :Добавя нов елемент в началото на списъка.
Нека видим пример, който демонстрира използването на функции push_back и push_front.
#include #include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3}; cout<<'List elements are: '; printlist(mylist); mylist.push_front(0); mylist.push_back(5); cout<<'
List contents after push_front and push_back: '; printlist(mylist); }Изход:
Елементите на списъка са: 1 1 2 3
Съдържание на списъка след push_front и push_back: 0 1 1 2 3 5
В този пример първо създаваме и изброяваме всички два елемента към него, по един отпред и отзад, като използваме съответно функции push_front и push_back. Резултатът показва променения списък след изпълнението на двете функции.
- pop_back :Премахва последния елемент в списъка, като по този начин намалява размера на списъка с 1.
- pop_front :Премахва първия елемент в списъка, като по този начин намалява размера на списъка с 1.
Следващият пример показва използването на операциите pop_back и pop_front на списъка.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); mylist.pop_front(); mylist.pop_back(); cout<<'
List contents after push_front and push_back: '; printlist(mylist); }Изход:
Елементите на списъка са: 1 1 2 3 5
Съдържание на списъка след push_front и push_back: 1 2 3
Както е описано в дефиницията на операциите, всяка от операциите pop_front и pop_back премахва елемента отпред и отзад на списъка, т.е. съответно първия и последния елемент на списъка и по този начин всеки път намалява размера на списъка с 1.
- размер :Връща размера на списъка, т.е. броя на елементите в списъка.
- празен :Проверява дали списъкът е празен.
- изтрива :Премахва елемент или диапазон от елементи от списъка.
- ясно :Премахва всички елементи от списъка, като го прави до 0 размер.
По-долу е даден пример за демонстриране на използването на всички горепосочени функции, т.е. размер, празен, изтрит и изчистен.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); cout<<'size of the list: '< Изход:
Елементите на списъка са: 1 1 2 3 5
размер на списъка: 5
Списък след изтриване на първия елемент: 1 2 3 5
Нов размер на списъка: 4
размер на списъка след изчистване: 0
Горната програма демонстрира всичките четири функции, свързани с капацитета на списъка. Виждаме, че размерът на списъка намалява с 1, когато изтрием 1 елемент от списъка. Докато когато извикаме ясна операция в списъка, размерът е 0, което означава, че всички елементи в списъка са премахнати.
- отпред :Връща стойността на първия елемент от списъка.
- обратно :Връща стойността на последния елемент от списъка.
- размяна :Разменя съдържанието на един списък със съдържанието на друг списък със същия размер и тип.
- обратен :Алгоритъм, който обръща списъка.
- вид :Сортира дадения списък.
Примерът по-долу демонстрира използването на предни, задни, обратни, сортиращи и суап функции.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); cout<<'
Front of the list: '< Изход:
Елементите на списъка са: 1 1 2 3 5
Предната част на списъка: 1
Гърб на списъка: 5
Обърнат списък: 5 3 2 1 1
Съдържание на нечетен списък: 1 3 5 7 9
След размяна
mylist: 1 3 5 7 9
Странен списък: 5 3 2 1 1
В този код първо отпечатваме предните и задните стойности на списъка mylist. След това този списък се обръща и се отпечатва обратния списък. След това определяме още един списък с нечетни числа, който не е в произволен ред и извикваме алгоритъма „Сортиране“, за да сортираме този списък. След това сменяме двата списъка с помощта на функцията за суап и отпечатваме разменените списъци.
- снаждане :Тази функция се използва за прехвърляне на съдържанието на един списък в друг списък на определена позиция.
И двата списъка трябва да бъдат от един и същи тип.
снаждане (позиция, списък);
където,
position => Позиция, на която трябва да се прехвърли съдържанието на списъка.
list => Списък, чиито елементи трябва да бъдат прехвърлени.
Примерът, даден по-долу, показва използването на функцията за снаждане.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 8,13}; cout<<'List elements are: '; printlist(mylist); list seclist = {2,3,5}; cout<<'list to be spliced: '; printlist(seclist); list:: iterator it = mylist.begin(); it ++; it++; mylist.splice(it,seclist); cout<<'
List contents after splicing at position 2: '; printlist(mylist); } Изход:
Елементите на списъка са: 1 1 8 13
списък за сплайсинг: 2 3 5
Съдържание на списъка след снаждане в позиция 2: 1 1 2 3 5 8 13
The пример показва, че използваме два списъка. Първо, итераторът за mylist се премества на две позиции и след това се извиква функцията за снаждане, за да прехвърли съдържанието на втория списък на третата позиция на първия списък.
въпроси и отговори за ъглово интервю за js
- отивам :За разлика от функцията за снаждане, която може да се използва за прехвърляне на съдържание от един списък в друг на определена позиция, операцията за сливане директно обединява два списъка, за да образува един единствен списък. За операция на обединяване и двата списъка трябва да бъдат в сортиран ред.
По-долу е даден пример за демонстриране на функцията за сливане.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1,2,3,5,8}; list seclist = {4,6,7}; cout<<'First List: '; printlist(mylist); cout< Изход:
Първи списък: 11 2 3 5 8
Втори списък: 4 6 7
Съдържание на списъка след обединяване на два списъка:
1 1 2 3 4 5 6 7 8
По този начин в горната програма имаме два списъка, които са сортирани. Ние наричаме операция за сливане на тези два списъка. Полученият списък е сортиран списък, съдържащ елементите на двата списъка.
Заключение
Стигнахме до края на този урок за Списъци в STL. Надяваме се, че този урок ще ви даде огромни познания за Списъци в STL.
=> Проверете тук, за да видите A-Z на C ++ уроци за обучение тук.
Препоръчително четене