Обръщане на низове в C++

Obr Sane Na Nizove V C



В много сценарии за програмиране на C++ може да е необходимо да обърнете низ. Обръщането на низ включва промяна на реда на знаците в низа и настройването му в обратен ред или може просто да бъде отпечатан низ назад. Всичко, което е необходимо за обръщане на низ, е да преместите крайния му елемент на първоначалното място на низа и т.н. В някои ситуации може да се наложи да обърне низа на неговия адрес за постоянно. C++ предоставя различни методи за обръщане на низа.

Техники за обръщане на низ в програмирането на C++

В зависимост от спецификациите на кода, които разработваме, съществуват няколко техники за прилагане на обръщането на низа в програмирането на C++. Тези техники са:

  • Използване на метода 'reverse()'.
  • Използване на метода „strrev()“.
  • Използване на цикъла „for“.
  • Използване на цикъла 'while'.
  • Използване на конструктора

Пример 1:

Първо импортираме три отделни заглавни файла, които са „алгоритъм“, „iostream“ и „низ“. Трябва да включим тези заглавни файлове, за да използваме функциите, които са дефинирани в тях. Заглавният файл „алгоритъм“ включва множество вградени функции за намиране, сортиране, преброяване, модифициране и т.н., които са ни достъпни.







След това „iostream“ предоставя функции за въвеждане или извеждане на данните, а заглавният файл „string“ е включен, тъй като предоставя функциите, необходими при работа с низовите данни. Под тези заглавни файлове добавяме пространството от имена „std“. Тук извикваме функцията 'main()'.



След това поставяме типа данни „низ“ и инициализираме „originalStr“ тук с някои низови данни. След това отпечатваме този низ. След това използваме метода „reverse()“, който помага при обръщане на низа. В този метод „reverse()“ добавяме „begin()“ и „end()“ заедно с променливата „originalStr“. Сега също отпечатваме този обърнат низ, който получаваме след прилагане на метода „reverse()“.



Код 1:





#include <алгоритъм>
#include
#include<низ>
използвайки пространство от имена std ;
вътр основен ( )
{
низ originalStr = „Обръщане на низ в C++ програмиране“ ;
cout << „Оригиналната струна!“ << endl ;
cout << originalStr << endl << endl ;
обратен ( originalStr. започвам ( ) , оригинална ул. край ( ) ) ;
cout << 'Обърнатият низ!' << endl ;
cout << originalStr ;
връщане 0 ;
}

Изход:
Обърнатият низ, който получаваме след прилагане на метода „reverse()“ в нашия код, сега се изобразява заедно с оригиналния низ.



Пример 2:

Първо включваме заглавните файлове и след това поставяме „namespace std“. След това в метода “main()” инициализираме масива от знаци, като поставим типа данни “char” с името на променливата “Org_str” и тук въвеждаме низа, който искаме да обърнем. След това изобразяваме този „Org_str“ с помощта на „cout“.

Под това използваме метода „strrev()“, за да обърнем низа и да предадем „Org_str“ като параметър в тази функция. Сега низът е обърнат тук. След това изобразяваме и обратния низ с помощта на „cout“.

Код 2:

#include
#include
използвайки пространство от имена std ;
вътр основен ( )
{
въглен Org_str [ ] = „Програма за обръщане на низове“ ;
cout << Org_str << endl << endl ;
strrev ( Org_str ) ;
cout << 'Обърнат низ' << endl ;
cout << Org_str ;
връщане 0 ;
}

Изход:
Тук се изобразяват оригиналните и обърнатите низове, които получихме от използването на метода „strrev()“ в нашия код.

Пример 3:

В този случай заглавните файлове се включват, преди да се добави „namespace std“. След това се извиква „main()“ и низовата променлива се добавя с името „myOrgStr“ и се инициализира с низовите данни.

След това ние също декларираме променливата „int“ „a“ и изобразяваме низа „myOrgStr“, използвайки „cout“. Под това използваме цикъла „for“, където инициализираме променливата „a“ с „myOrgStr.length() – 1“ и след това поставяме условие, което е „a >= 0“ и го намаляваме в стойността на „a ”. Това обръща нашия низ и го съхранява в “myOrgStr[a]” и също така го показва, когато поставим “myOrgStr[a]” вътре в “cout”.

Код 3:

#include
#include<низ>
използвайки пространство от имена std ;
вътр основен ( )
{
низ myOrgStr = 'Здравей свят!' ;
вътр а ;
cout << myOrgStr << endl << endl ;
cout << 'Обърнат низ' <= 0 ; а -- )
{
cout << myOrgStr [ а ] ;
}
връщане 0 ;
}

Изход:
Това изобразява както оригиналния, така и обърнатия низ, който получихме чрез нашия код, използвайки метода за цикъл.

Пример 4:

Тук импортираме заглавния файл „bits/stdc++.h“, така че не е необходимо да импортираме другите заглавни файлове, тъй като този заглавен файл съдържа всички дефиниции на функцията. След това въвеждаме „namespace std“. Тук създаваме функция с име „Rev()“, в която предаваме „string& myString“ като аргумент на тази функция. Създаваме тази функция тук, за да обърнем низа.

В тази функция поставяме променливата „S_len“ от типа данни „int“ и я инициализираме с функцията „length()“, като поставяме „myString“ с това. След това имаме друга променлива, която е „не“ от тип данни „int“ и я инициализираме с „S_len-1“.

Под това се инициализира още една променлива, която се нарича 'a' от типа данни 'int'. Тук използваме цикъла “while()” и добавяме “a <= no” като условие. След това използваме метода 'swap()'. Този метод “swap()” подпомага размяната на низовите данни и след това инициализира “no” с “no -1”. Също така инициализираме „a“ с „a+1“.

След това извикваме “main()” тук, в който инициализираме променливата “myString” с низовите данни и отпечатваме този низ. След това извикваме функцията „Rev()“, която създадохме в този код и поставяме „myString“ като параметър на тази функция, която обръща низа и след това показва обърнатия низ.

Код 4:

#include
използвайки пространство от имена std ;
невалиден Rev ( низ и myString )
{
вътр S_len = myString. дължина ( ) ;
вътр Не = S_len - 1 ;
вътр а = 0 ;
докато ( а <= Не ) {
размяна ( myString [ а ] ,myString [ Не ] ) ;
Не = Не - 1 ;
а = а + 1 ;
}

}
вътр основен ( )
{
низ myString = 'Обичам програмирането' ;
cout << myString << endl ;
cout << ' Обърнат низ' << endl ;
Rev ( myString ) ;
cout << myString ;
връщане 0 ;
}

Изход:
Тук представяме както оригиналния низ, така и обърнатия низ, който получихме чрез използване на цикъла „while()“ и метода „swap()“ във функцията, която създадохме в нашия код.

Пример 5:

Ние импортираме заглавния файл 'bits/stdc++.h' с всички дефиниции на функциите. Следователно не е необходимо да импортираме други заглавни файлове. След това въвеждаме „namespace std“ и извикваме „main()“ тук. След това имаме променлива „данни“ от типа данни „низ“ и я инициализираме с низа, който искаме да обърнем.

Изобразяваме този оригинален низ, преди да го обърнем, като поставим променливата „data“ в „cout“. Под това инициализираме друга променлива, която е „revStr“ от същия тип данни „низ“. След това използваме „rbegin()“ и „rend()“, които са обратните итератори, които добавяме за обръщане на низа тук. Обърнатият низ вече се записва в променливата „revStr“, която е поставена в „cout“, за да отпечатате обърнатия низ тук.

Код 5:

#включи
използвайки пространство от имена std ;
вътр основен ( )
{
низови данни = „C++ е най-добрият език за програмиране“ ;
cout << данни << endl << endl ;
низ revStr = низ ( данни. rbegin ( ) , данни. прави ( ) ) ;

cout << revStr << endl ;
връщане 0 ;
}

Изход:
Низът, който добавихме към кода, първо се изобразява тук. След това обърнатият низ, който получихме чрез използване на обратните итератори, се показва в следното:

Заключение

Концепцията за „обръщане на низ“ в програмирането на C++ се обсъжда в тази статия, където изследвахме множество техники за обръщане на низа. Проучихме подробно всички методи, които помагат за обръщане на низа в C++ и обърнахме низа в нашите C++ кодове. В тази статия показахме оригиналните и обърнатите низове в нашите кодове.