შექმნის ერთი განზომილებიანი მასივი გვ. სტატიკური მასივი: განცხადება, შევსება, გამოყენება

Arrays არის ძალიან მნიშვნელოვანი თემა C + +. პროგრამებში ისინი ძალიან ხშირად იყენებენ და ეს თემა კარგად გვესმის. სასწრაფოდ გავაკეთებ მას - მესმის და ვისწავლოთ ვრცელდება მასივები საკმაოდ უბრალოდ დამწყები.

ასე რომ, რატომ გვჭირდება მასრები და რას წარმოუდგენია ისინი? დღემდე, თქვენ უკვე კარგად იცით, რომ ეს პროგრამები ინახება გამოცხადებულ. მაგრამ ეს ხდება, რომ პროგრამა უნდა შეინარჩუნოს ასობით (ან უფრო მეტი) ცვლადები იმავე ტიპის მონაცემებით, და ასევე აუცილებელია მათთან მუშაობა - ღირებულებების მინიჭება, მათ შეცვალონ ისინი და ა.შ.

მაგალითად, თქვენ უნდა შეინახოთ რიგითი რიგები ნომრები. ვეთანხმები - ნებისმიერი იქნება საშინელი აზროვნების, რომ თქვენ უნდა შექმნათ ხუთასი ცვლადი ტიპის int, თითოეული მისცეს უნიკალური სახელი და მიანიჭოს ღირებულება 1-დან 500-მდე. (მე უკვე საშინელი :) ამ შემთხვევაში, მასივები უბრალოდ დაზოგავს us.

ჩვენ აღვნიშნავთ მთავარ და გაგრძელდება პრაქტიკული მაგალითი:

• მასივი C + + არის კომბინაცია გარკვეული რაოდენობის ერთი ტიპის ცვლადები, რომ აქვს ერთი სახელი. Მაგალითად, int array; . ეს ჩანაწერი ნიშნავს, რომ ჩვენ დაასახელა მასივი მასივი. , რომელიშეიცავს 3 ცვლადი ტიპი int. ;
• ცვლადების მასივი მოუწოდა ელემენტებს;
• თითოეულ ელემენტს აქვს საკუთარი უნიკალური ინდექსი - საკუთარი სერიული ნომერი. ინდექსის გამოყენებით, ჩვენ შეგვიძლია მივმართოთ კონკრეტულ ელემენტს. ᲛᲜᲘᲨᲕᲜᲔᲚᲝᲕᲐᲜᲘ - ინდექსირების მასივი ელემენტები იწყება 0 . ასე რომ მასივი int array. პირველი ელემენტია ინდექსი 0 , და ბოლო - 2 . კონტაქტისთვის, მაგალითად, მასივის ნულოვანი ელემენტისა და მისი ღირებულების შეცვლა, თქვენ უნდა მიუთითოთ მასივის სახელი და კვადრატულ ფრჩხილებში მითითებულია ელემენტის ინდექსი - array \u003d 33. .

განვიხილოთ მაგალითი:

c ++ მასივები

/ / ამ პროგრამაში, შექმნა მასივი ზომა ზომა, // გამოყენებით ციკლი, ჩვენ წარმოგიდგენთ მონაცემებს ყველა საკნებში // მასივი და აჩვენებს მათი შინაარსი # მოიცავს ეკრანზე Namespace STD- ის გამოყენებით; Int main () (setlocale (lc_all, "RUS"); Const Int ზომა \u003d 10; / ჩვენ ვაცხადებთ int პირველი ბაზარი; // ჩვენ ვაცხადებთ მასივი ზომის ელემენტების რაოდენობას (int i \u003d 0; i< SIZE ; i++) //заполняем и отображаем значения на экран { firstArray[i] = i + 1; // на первом шаге цикла firstArray присвоить 1 (0 + 1) cout << i << "-я ячейка хранит число " << firstArray[i] << endl; } cout << endl; return 0; }

/ / ამ პროგრამაში, შექმნა მასივი ზომის ზომა, / / ციკლის გამოყენებით, ჩვენ მონაცემების დანერგვა ყველა საკნებში / / array და აჩვენებს მათ შინაარსი ეკრანზე #Include. namespace STD- ის გამოყენებით; int main () setlocale (LC_ALL, "RUS"); const Int ზომა \u003d 10; / / გამოაცხადეთ მუდმივი iNT FASTARRAY [ზომა]; / / გამოაცხადეთ მასივი ზომის ელემენტების რაოდენობით (int i \u003d 0; მე< SIZE ; i ++ ) // შეავსეთ და აჩვენე ღირებულებები ეკრანზე firstarray [i] \u003d i + 1; / / პირველი საფეხბურთო ციკლის პირველი ნაბიჯი, 1 (0 + 1) cout.<< i << "- საკანში ინახავს ნომერს"<< firstArray [ i ] << endl ; cout.<< endl ; დაბრუნება 0;

ხაზი 12 ჩვენ განვსაზღვროთ მთელი რიცხვი მუდმივი ზომარომელიც შეინახავს მასივის ზომას (ჩვენ განვსაზღვრავთ, მისი ელემენტების ოდენობა). 13-ში, ჩვენ ვაცხადებთ მასივს: მიუთითეთ მონაცემების ტიპი, რომელიც ინახება მასივში უჯრედებში, მისცეს სახელი და მიუთითეთ ზომა კვადრატულ ფრჩხილებში.

მნიშვნელოვანია, რომ კვადრატულ ფრჩხილებში ჩვენ შეგვიძლია მხოლოდ მუდმივი ღირებულებების ჩაწერა. აუცილებელია, რომ დაუყოვნებლივ შეიყვანოთ მთელი კვადრატულ ფრჩხილებში, როდესაც მასივის გამოცხადებისას ( int firstarray;), ან განსაზღვრავს მთელი რიცხვის მუდმივი ადრე დეკლარაციის მასივი და შევა კვადრატულ ფრჩხილებში ამ მუდმივი (როგორც ჩვენს მაგალითში).

მეორე მეთოდი სასურველია, თუ პროგრამის განმავლობაში თქვენ უნდა წვდომის მასივი რამდენჯერმე ციკლის მეშვეობით. ეს აიხსნება იმით, რომ როდესაც ციკლის გამოცხადებისას, შეიძლება განისაზღვროს მასში, რათა მიუთითოს მეტრის შეცვლის მდგომარეობა ზომა .

წარმოიდგინეთ, რომ ჩვენ უნდა შეიცვალოს მასივის ზომა 10 ელემენტებით 200-ზე. ამ შემთხვევაში, ჩვენ შეგვიძლია მხოლოდ უნდა შეიცვალოს რიცხვის მუდმივი მნიშვნელობა, და ამით ავტომატურად წარუდგენს ახალ ზომას ღირებულებებს მასივში ყველა პროგრამის ციკლი.

თქვენ შეგიძლიათ სცადოთ ჩვენს მაგალითზე, რათა სხვა ციფრი მუდმივად გააკეთოთ ზომა . და ნახავთ, რომ პროგრამა კარგად იმუშავებს - შექმნა მასივი ამდენი ელემენტი, როგორც თქვენ დააკონკრეტებთ, გახდის მონაცემებს და აჩვენებს მათ ეკრანზე.

და თუ მასივი სრულიად მცირეა, მაგალითად, 5 ელემენტს, შესაძლებელია დაუყოვნებლივ გამოაცხადოს:

ასე რომ ელემენტი ინდექსით 0 - firstarray. - მინიჭება იქნება ღირებულება 11 , და მასივის ბოლო ელემენტი firstarray. - მნიშვნელობა 1 5 . არსებობს ასეთი ჩიპი - თქვენ არ შეგიძლიათ დააკონკრეტოთ ზომის მასივი კვადრატულ ფრჩხილებში და გააკეთეთ ასეთი ჩანაწერი:

წინა ჩანაწერი არის ეკვივალენტურია. მხოლოდ მეორე შემთხვევაში, შემდგენელი ავტომატურად გაანგარიშებს მასივის ზომას, ფიგურულ ფრჩხილებში მონაცემების ოდენობით.

ასევე, მასივის ელემენტების თავდაპირველი ინიციალიზაციისას, როდესაც მასივი უნდა გაიწმინდოს "ნაგავიდან" (მეხსიერების სხვა პროგრამების ნარჩენი მონაცემები) უკეთესია ყველა ელემენტისთვის 0 . ეს ასე გამოიყურება:

უნდა აღინიშნოს, რომ ასეთი ინიციალიზაცია შესაძლებელია მხოლოდ ზეროზთან შეავსოთ. თუ თქვენ უნდა შეავსოთ მასივის ელემენტები ნებისმიერი სხვა ნომრებით, უმჯობესია ციკლის გამოყენება. C ++ 11 (კოდირების სტანდარტი), როდესაც ჩამოთვლილი ინიციალიზაციისას (Curly ფრჩხილების ინიციალიზაცია), მას უფლება აქვს, ხელი შეუშალოს = .

მასივის შექმნისას კიდევ ერთი ინიციალიზაციის მიღება მინდა. მაგალითად, 30 ელემენტის მასივისთვის, ჩვენ გვჭირდება ღირებულებები 33 და 44 მხოლოდ საკნებში ინდექსით 0 და 1 შესაბამისად, დანარჩენი ივსება zeros. ამის შემდეგ:

ეს მონაცემები ნულოვანია და პირველი უჯრედებში შევა და დანარჩენი ავტომატურად მიიღებს ღირებულებას 0 .

ოპერატორის გამოყენებით მასივის შევსების ორგანიზება შესაძლებელია cIN.:

(int i \u003d 0; მე< size; i++) //заполняем и выводим значения на экран { cout << "Введите значение в ячейку №" << i << " :"; cin >\u003e Firstirray [I]; )

(int i \u003d 0; მე< size ; i ++ ) // შეავსეთ და აჩვენე ღირებულებები ეკრანზე

წყლი

წყობა ეს არის ერთი ტიპის ცვლადების კომპლექტი საერთო სახელით. C #, მასივები შეიძლება იყოს როგორც ერთი განზომილებიანი და მრავალგანზომილებიანი. მასივები ყველაზე განსხვავებული მიზნებია, რადგან ისინი უზრუნველყოფენ ასოცირებული ცვლადების კომბინირებას.

C # მასივები შეიძლება გამოყენებულ იქნას თითქმის ისევე, როგორც სხვა პროგრამირების ენებზე. მიუხედავად ამისა, მათ აქვთ ერთი ფუნქცია: ისინი ხორციელდება ობიექტად.

ერთი გამოიყენოს მასივი პროგრამაში, საჭიროა ორი ნაბიჯი პროცედურა, რადგან მასივები ობიექტების სახით ხორციელდება. პირველი, აუცილებელია გამოაცხადოს ცვლადი, რომელსაც შეუძლია მასივის წვდომა. და მეორე, თქვენ უნდა შექმნათ მასივის მაგალითი ახალი განცხადების გამოყენებით.

სისტემის გამოყენებით; გამოყენებით system.COLLECTIONS.GENIC; გამოყენებით system.linq; სისტემის გამოყენებით. Namespace ConsoleApplication1 (String args (// ჩვენ ვაცხადებთ int myarr \u003d ახალი int; // მასივის თითოეული ელემენტის ინიციალიზაცია ხელით myarr \u003d 100; myarr \u003d 25; myarr \u003d 31; myarr \u003d 1; In Myarr) console.writeline (i); console.readline ();))

უნდა აღინიშნოს, რომ თუ მასივი მხოლოდ გამოცხადდება, მაგრამ არ არის აშკარად ინიციალიზებული, თითოეული ელემენტი იქნება მითითებული შესაბამისი მონაცემთა ტიპისთვის (მაგალითად, Bool ტიპის მასივის ელემენტები დამონტაჟდება ყალბი , და ელემენტები int ტიპის მასივი - 0).

მასივის ინიციალიზაცია

ელემენტის მიღმა მასივის ელემენტის შევსების გარდა (როგორც წინა მაგალითში ნაჩვენებია), ასევე შეგიძლიათ შეავსოთ იგი სპეციალური სინტაქსის ინიციალიზაციისათვის. ამისათვის აუცილებელია ჩამოთვალეთ ელემენტები, რომლებიც შედის მასივში ჩამოსულ ფრჩხილებში (). ასეთი სინტაქსი არის მოსახერხებელი, როდესაც შექმნას ცნობილი ზომის მასივი, როდესაც თქვენ უნდა სწრაფად დააყენოთ მისი საწყისი ღირებულებები:

// მასობრივი ინიციალიზაცია სინტაქსი გამოყენებით // საკვანძო სიტყვა ახალი int myarr \u003d ახალი int (10,20,30,40,50); // სინტაქსი მასივის ინიციალიზაციის გარეშე გამოყენების გარეშე // Keywords New String Info \u003d ("გვარი", "სახელი", "პატრონომიული"); / / გამოიყენეთ საკვანძო სიტყვები ახალი და სასურველი ზომა char სიმბოლო \u003d ახალი char ("x", "Y", "Z", "M");

გთხოვთ გაითვალისწინოთ, რომ სინტაქსის გამოყენების შემთხვევაში Curly ფრჩხილებში, მასივის ზომა არ არის საჭირო (როგორც ჩანს, Myarr ცვლადი შექმნის მაგალითზე), რადგან ეს ზომა ავტომატურად გამოითვლება ნომერზე ელემენტების შიგნით ფიგურა ფრჩხილებში. გარდა ამისა, ვრცელდება სიტყვით ახალი არ არის აუცილებელი (როგორც ინფორმაციის მასივის შექმნისას).

Var Keyword გაძლევთ საშუალებას განსაზღვროს ცვლადი ისე, რომ ტიპის ძირითადი ტიპის ნაჩვენებია მიერ შემდგენელი. ანალოგიურად, თქვენ ასევე შეგიძლიათ განსაზღვროთ მინიშნებით აკრეფილი ადგილობრივი მასივები. ამ მიდგომის გამოყენებით, შეგიძლიათ განსაზღვროთ ახალი მასივი ცვლადი მასივში არსებული ელემენტების მითითების გარეშე. განვიხილოთ მაგალითი:

სისტემის გამოყენებით; გამოყენებით system.COLLECTIONS.GENIC; გამოყენებით system.linq; სისტემის გამოყენებით. Namespace ConsoleApplication1 (სიმებიანი args (სიმებიანი args) (var arr1 \u003d ახალი (1, 2, 3); console.writeline ("მასივი arr1 - (0)" ტიპი arr1.gettype ()); var arr2 \u003d ახალი (" ერთი "," ორი "," სამი "); console.writeline (" მასივი arr2 - (0) ", arr2.gettype ()); console.Readline ();))

რა თქმა უნდა, როგორც მასივის შექმნისას, სინტაქსის გამოყენებით, მასობრივი ინიციალიზაციის სიაში მითითებული ელემენტები აუცილებლად უნდა ჰქონდეს იგივე საბაზისო ტიპის (I.E. ყველაფერი უნდა იყოს int, სიმებიანი ან mycar).

ობიექტების მასივის განსაზღვრა

უმეტეს შემთხვევაში, მასივის განსაზღვრისას, მასივში არსებული ნივთის ტიპი აშკარად არის მითითებული. მიუხედავად იმისა, რომ ერთი შეხედვით ჩანს საკმაოდ ნათელი, არსებობს ერთი მნიშვნელოვანი ფუნქცია. თითოეული ტიპის გულში Type.net- ის სისტემაში (მათ შორის ფუნდამენტური მონაცემთა ტიპების ჩათვლით), ძირითადი კლასის სისტემა. შედეგად, აღმოჩნდება, რომ მასშტაბის ობიექტების მასივის განსაზღვრის შემთხვევაში, ელემენტი შეიძლება იყოს არაფერი:

სისტემის გამოყენებით; გამოყენებით system.COLLECTIONS.GENIC; გამოყენებით system.linq; სისტემის გამოყენებით. Namespace ConsoleApplication1 (STRING args) (// აცხადებს ობიექტების ობიექტების ობიექტის arryobject \u003d (True, 10, Hello, 13.7m); // გაყვანის ყოველი წევრი Foreach Massif (ობიექტი Me in arryobject) Console.writeline ("ტიპი (0) - (1)", მე, me.gettype ()); console.readline ();))

ჩვენ ვაგრძელებთ C + +- ს საფუძვლებზე. ამ სტატიაში ჩვენ შევხედავთ მასებს.

მასივები საშუალებას იძლევა მოსახერხებელი ფორმატში შესანახად დიდი რაოდენობით მონაცემები. Სინამდვილეში, წყობა - ეს არის ცვლადი, რომელიც ერთ სახელს ბევრ ღირებულებას ინახავს, \u200b\u200bმაგრამ თითოეული მნიშვნელობა საკუთარ ინდექსს ენიჭება. - ეს არის ღირებულებების ჩამონათვალი, რომელიც ხელმისაწვდომი იქნება, თუ რომელი ინდექსები გამოიყენება.

შესავალი მასივები

თქვენ შეგიძლიათ ვიზუალიზაცია მასივი შემდეგნაირად:

ეს არის რამდენიმე ღირებულებების კომპლექტი, რომელიც ინახება ერთმანეთის მიერ ერთი სახელით. ამ ღირებულებების მისაღებად, თქვენ არ უნდა შეიქმნას ახალი ცვლადები, თქვენ მხოლოდ უნდა მიუთითოთ ინდექსი, რომლის მიხედვითაც ღირებულება ინახება მასივში. მაგალითად, თქვენ უნდა გაითვალისწინოთ Poker- ის ხუთი სათამაშო ბარათის კომპლექტი, თქვენ შეგიძლიათ შეინახოთ ეს ბარათები მასივში და აირჩიოთ ახალი ბარათი მხოლოდ ინდექსის ნომრის შესაცვლელად, ნაცვლად იმისა, რომ გამოიყენოთ ახალი ცვლადი. ეს საშუალებას მისცემს იმავე კოდს გამოიყენოს ყველა რუკის ინიციალიზაცია და ასეთი შესვლისგან გადაადგილება:

Card1 \u003d getrandomcard (); Card2 \u003d getrandomcard (); Card3 \u003d getrandomcard (); Card4 \u003d getrandomcard (); ბარათის 5 \u003d GetRandomcard ();

(Int i \u003d 0; მე< 5; i++) { card[i] = getRandomCard(); }

და ახლა წარმოიდგინეთ განსხვავება, თუ 100 ცვლადები!

Სინტაქსი

გამოაცხადოს მასივი, თქვენ უნდა მიუთითოთ ორი რამ (სახელით): მასივის ტიპი და ზომა:

Int my_array [6];

ეს სიმებიანი აცხადებს ექვსი რიცხვითი ღირებულებების მასივი. გთხოვთ გაითვალისწინოთ, რომ მასივის ზომა მასივის სახელით არის მოთავსებული კვადრატულ ფრჩხილებში.

მასივის ელემენტების ხელმისაწვდომობისთვის გამოიყენება კვადრატული ფრჩხილები, მაგრამ ამჯერად თქვენ განსაზღვრავთ ელემენტის ინდექსს:

My_array [3];

თქვენ შეგიძლიათ ამ პროცესის ვიზუალიზაცია:

my_array ეხება მთელი მასივის მთელი მასივი, ხოლო My_array მხოლოდ პირველი ელემენტია, My_array არის მეოთხე. ჩაინიშნე ინდექსირება მასივის ელემენტები იწყება 0. ამგვარად, მასივის ელემენტების მიმართვა ყოველთვის გადაადგილდება, მაგალითად:

Int my_array [4]; / / მასიური My_array [2] \u003d 2; / / მითითებული ღირებულება მესამე (ზუსტად მესამე!) თანაბარი 2

მრავალგანზომილებიანი მასივების გამოცხადება C + + -ში

მასივები ასევე შეიძლება გამოყენებულ იქნას მრავალგანზომილებიანი მონაცემების წარმოდგენისთვის, როგორიცაა, როგორიცაა ჭადრაკის დაფა ან ნოლიკი ჯვრის სათამაშოდ. მასივის ელემენტების წვდომისას მრავალგანზომილებიანი მონაცემების გამოყენებისას რამდენიმე ინდექსი გამოყენებული იქნება.

ორ განზომილებიანი მასივის გამოცხადების მიზნით, თქვენ უნდა მიუთითოთ ორი განზომილების განზომილება:

Int tic_tac_toe_board;

მასივის ინდექსების ვიზუალიზაცია:

ასეთი მასივის ელემენტების წვდომისათვის საჭიროა ორი ინდექსის საჭიროება - ერთი სვეტისთვის მეორე სტრიქისთვის. გამოსახულება გვიჩვენებს სასურველ ინდექსებს თითოეული ნივთის შესასვლელად.

იარაღის გამოყენება

მასალის გამოყენებისას, თქვენ არ შეგიძლიათ გააკეთოთ გარეშე. ციკლის ირგვლივ, უბრალოდ, ნულოვანი ცვლადი და გაზრდის მას, სანამ არ აღემატება მასივის ზომას - თარგი მხოლოდ ციკლისთვის განკუთვნილია.

შემდეგი პროგრამა აჩვენებს ციკლის გამოყენებას ორ განზომილებიანი მასივის გამრავლებისა და შენახვის მაგიდის შესაქმნელად:

#Include. Namespace STD- ის გამოყენებით; int major () (int array; // აცხადებს მასივი, რომელიც ჰგავს ჭადრაკის დაფას (int i \u003d 0; მე< 8; i++) { for (int j = 0; j < 8; j++) { array[i][j] = i * j; // Задаем значения каждого элемента } } cout << "Multiplication table:\n"; for (int i = 0; i < 8; i++) { for (int j = 0; j < 8; j++) { cout << "[ " << i << " ][ " << j << "] = "; cout << array[i][j] << " "; cout << "\n"; } } }

ჩვენ გადავიტანთ მასებს ფუნქციაში

როგორც ხედავთ, C ++ ენის სხვადასხვა ელემენტები ერთმანეთთან ურთიერთქმედებენ. როგორც ციკლები, მასივები შეიძლება გამოყენებულ იქნას.

ფუნქციის მასივის გადასატანად უბრალოდ მიუთითეთ მისი სახელი:

INT ღირებულებები [10]; Sum_array (ღირებულებები);

და ფუნქციის გამოცხადებისას, მიუთითეთ მასივი, როგორც არგუმენტი:

Int sum_array (int ღირებულებები);

გთხოვთ გაითვალისწინოთ, რომ ჩვენ არ დააკონკრეტებთ ფუნქციის არგუმენტებში მასივის განზომილებას, ეს ნორმალურია, ერთი განზომილებიანი მასივებისთვის, თქვენ არ გჭირდებათ განზომილება. ზომა უნდა იყოს მითითებული იარაღის გამოცხადება იმიტომ რომ შემდგენელი უნდა იყოს ცნობილი, თუ რამდენად უნდა აღინიშნოს მეხსიერება. ფუნქციის გადაცემისას, ჩვენ უბრალოდ გადასცემს არსებულ მასივს; არ არის საჭირო ზომის დაზუსტება, რადგან ჩვენ არ შევქმნით ახალს. იმიტომ რომ ჩვენ გადავცემთ მასივის ფუნქციას, ფუნქციის შიგნით შეგვიძლია გამოცვლამარტივი ცვლადებისგან განსხვავებით, რომლებიც გადადიან ღირებულებით და ამ მნიშვნელობის შეცვლას ფუნქციის შიგნით არ იმოქმედებს ორიგინალური ცვლადი.

მას შემდეგ, რაც შიგნით ფუნქცია, ჩვენ არ ვიცით ზომა მასივი, აუცილებელია გადარიცხოს განზომილება, როგორც მეორე არგუმენტი:

Int sumarray (int ღირებულებები, int ზომა) (int sum \u003d 0; for (int i \u003d 0; მე< size; i++) { sum += values[ i ]; } return sum; }

როდესაც ჩვენ გადაცემული მრავალგანზომილებიანი მასივები, თქვენ უნდა მიუთითოთ ყველა ზომები, გარდა პირველი:

Int check_tic_tac_toe (int board);

რა თქმა უნდა, შეგიძლიათ მიუთითოთ პირველი განზომილება, მაგრამ ის იგნორირებულია.

უფრო მეტიც, ამ თემას სტატიაში მითითებულია მითითებები.

იმავდროულად, დაწერეთ ფუნქცია, რომელიც ითვლის მასივის ელემენტების რაოდენობას:

#Include. Namespace STD- ის გამოყენებით; int sumarray (int ღირებულებები, int ზომა) (int sum \u003d 0; // ციკლი შეწყდება, როდესაც i \u003d\u003d ზომა, რადგან ბოლო ელემენტის მაჩვენებელი \u003d ზომა - 1 (int i \u003d 0; i< size; i++) { sum += values[i]; } return sum; } int main() { int values; for (int i = 0; i < 10; i++) { cout << "Enter value " \u003c\u003c I \u003c\u003c": "; cin >\u003e ღირებულებები [I]; ) Cout<< sumArray(values, 10) << endl; }

დახარისხება მასივი

ჩვენ გადავწყვეტთ ამოცანას 100 ნომრის მასივის დახარისხების ამოცანას:

#Include. Namespace STD- ის გამოყენებით; Int main () (int ღირებულებები [100]; for (int i \u003d 0; მე< 100; i++) { cout << "Enter value " \u003c\u003c I \u003c\u003c": "; cin >\u003e ღირებულებები [I]; )

მზად არის, ის რჩება მხოლოდ ამ მასივის დასალაგებლად 🙂 როგორც ჩვეულებრივი ადამიანი აყალიბებს მასებს? ისინი ეძებენ მასში ყველაზე პატარა ელემენტს და სიის ზედა ნაწილში. შემდეგ ისინი ეძებენ შემდეგ მინიმალურ ღირებულებას და დაუყოვნებლივ და ა.შ.

ყველა ეს შემთხვევა გამოიყურება ციკლი: გაშვებული მასივი, დაწყებული პირველი ელემენტისაგან და ჩვენ ვეძებთ მინიმალურ ღირებულებას დარჩენილი ნაწილისა და ამ ელემენტების შეცვლას. დავიწყოთ ეს ოპერაციების შესასრულებლად კოდი:

ბათილი სახის (int array, int ზომა) (for int i \u003d 0; მე< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } }

ახლა თქვენ შეგიძლიათ იფიქროთ Findsmallestremainingelement- ის ორი დამხმარე მეთოდების განხორციელებაზე. FindSmallestremainingement მეთოდი უნდა გაიაროს მასივი და იპოვოს მინიმალური ელემენტი, დაწყებული ინდექსი I:

Int findsmallestremainingement (int array, int index_of_smallest_value \u003d ინდექსი (int i \u003d ინდექსი + 1; მე< size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = I; } } return index_of_smallest_value; }

საბოლოოდ, ჩვენ უნდა გადავიტანოთ სვოპ ფუნქცია. მას შემდეგ, რაც ფუნქცია ცვლის თავდაპირველ მასივს, ჩვენ უბრალოდ უნდა შეცვალოთ ღირებულებები ადგილებში დროებითი ცვლადი გამოყენებით:

VOID SWAP (int array, int first_index, int second_index) (int temp \u003d array [first_index]; მასივი [first_index] \u003d array [second_index]; array [second_index] \u003d temp;)

ალგორითმის გადამოწმების მიზნით, მასივი შემთხვევითი ნომრებით და დალაგებით. ყველა პროგრამის კოდი:

#Include. #Include. #Include. Namespace STD- ის გამოყენებით; Int findsmallestremainingement (int მასივი, int ზომა, int ინდექსი); VOID SWAP (int array, int first_index, int second_index); ბათილი სახის (int array, int ზომა) (for int i \u003d 0; მე< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } } int findSmallestRemainingElement(int array, int size, int index) { int index_of_smallest_value = index; for (int i = index + 1; i < size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = i; } } return index_of_smallest_value; } void swap(int array, int first_index, int second_index) { int temp = array[ first_index ]; array[ first_index ] = array[ second_index ]; array[ second_index ] = temp; } // вспомогательная функция для вывода массива void displayArray(int array, int size) { cout << "{"; for (int i = 0; i < size; i++) { // если элемент не первый выведем запятую if (i != 0) { cout << ", "; } cout << array[ i ]; } cout << "}"; } int main() { int array[ 10 ]; srand(time(NULL)); for (int i = 0; i < 10; i++) { array[ i ] = rand() % 100; } cout << "Original array: "; displayArray(array, 10); cout << "\n"; sort(array, 10); cout << "Sorted array: "; displayArray(array, 10); cout << "\n"; }

დახარისხების ალგორითმი, რომელიც ჩვენ უბრალოდ განიხილება ეწოდება დახარისხება მიერ ჩასმა ეს არ არის ყველაზე სწრაფი ალგორითმი, მაგრამ ადვილია გასაგები და განხორციელება. თუ თქვენ უნდა დაალაგოთ დიდი რაოდენობით მონაცემები, უმჯობესია გამოიყენოთ უფრო რთული და სწრაფად ალგორითმები.

გთხოვთ, პაუზა ამ საიტზე.

მასივი არის მარტივი კომპოზიტური მონაცემთა ტიპი. როდესაც ჩვენ განვიხილეთ ცვლადები, ჩვენ გვქონდა კარგი ანალოგია ყუთში. დავუბრუნდეთ მას. თუ ცვლადი არის ერთი ყუთი, მაშინ მასივი არის რამდენიმე დანომრილი იდენტური ყუთები, რომლებსაც აქვთ იგივე სახელი და განსხვავდებიან ერთმანეთისგან მხოლოდ თანმიმდევრობით.

Fig.1 ცვლადები და მასივები. ანალოგია ყუთებით.

სურათზე ზემოთ, სამი მასივი გამოსახულია:

• arr_int- ის 8 ელემენტის რიცხვის მასივი
• 11 ელემენტის ნამდვილი მასივი დაასახელა arr_float
• სიმბოლური მასივი 6 ელემენტის სახელწოდებით Arm_char

მასივი, ისევე როგორც ცვლადი, აქვს საკუთარი სახელი და მონაცემთა ტიპი. გარდა ამისა, მასივს ასევე აქვს ერთი დამატებითი დამახასიათებელი - მასივის ზომა. მასივის ზომა არის ის ელემენტების რაოდენობა, რომელიც შეიძლება ინახებოდეს მასში. ჩვენს ანალოგიაში ყუთებით, ეს არის ყუთების რაოდენობა.

Შენიშვნა!

მასივის ელემენტების ნუმერაცია ნულოვანით იწყება და არა ერთი.

მასივის განცხადება და ინიციალიზაცია

მასივის დეკლარაცია ძალიან ჰგავს ცვლადის გამოცხადებას. ერთადერთი განსხვავება ისაა, რომ დამატებით განსაზღვრავს კვადრატულ ფრჩხილებში მასივის ზომას. Აი ზოგიერთი მაგალითი:

ჩამონათვალი 1.

Int arr_int; ორმაგი ar_float; Float ნომერი;

მასივის სახელით, შეზღუდვები superimposed, მსგავსი იმ superimposed სახელით ცვლადი.

წესის დასახელება

მასივის სახელია სიმბოლოების ნებისმიერი თანმიმდევრობა, ციფრები და ქვედა ზედაპირის ნიშანი "_", რომელიც იწყება წერილში. მნიშვნელოვანია წერილების რეგისტრაცია.

აქ არის კიდევ რამდენიმე მაგალითი მასივები:

ჩამონათვალი 2.

Int კლასების, შეკვეთა; ორმაგი ფასები;

მასივი, ისევე როგორც ნებისმიერი ცვლადი, შეიძლება დანიშნოს თავდაპირველი ღირებულებები გამოცხადებისას. თუ მასივის ელემენტები არ არის მინიჭებული ნებისმიერი ღირებულება, მაშინ ნაგავი ინახება, როგორც ჩვეულებრივი ცვლადები.

ჩამონათვალი 3.

Int arr_int \u003d (2, 5, 5, 3, 4); ორმაგი arr_float \u003d (1.2, -2.3, 4.5, 3.83, 0.01, -0111112, 44.2, 123.7, 23.44, -3.7, 7, 7);

თუ თქვენ უნდა დაავალოს ნულოვანი ღირებულებები მასივის ყველა ელემენტზე, მაშინ ეს შეიძლება გაკეთდეს ასე:

ჩამონათვალი 4.

ორმაგი arr \u003d (0);

მასივის ცალკე ელემენტებთან მუშაობა

მასივის ცალკე ელემენტს, აუცილებელია მისი სახელი და სერიული ნომერი კვადრატულ ფრჩხილებში. ნუ დაგავიწყდებათ, რომ ნუმერაციის იწყება ნულიდან და არა ერთი.

მოდით, მაგალითად, გამოვტოვოთ ეკრანზე ხუთი ელემენტის მასივის ელემენტები.

ჩამონათვალი 5.

#Include. Int main (ბათილად) (int arr \u003d (2, 4, 3, 5, 5). (0);

რა თქმა უნდა, თუ მასივი ძალიან დიდია, მაშინ მარტო, ისევე, როგორც სიამოვნებით. დიახ, და პატარა მასივები, არავინ არ აკეთებს. უმჯობესია უფრო სწორად გამოიყენოთ ციკლები. Მაგალითად:

ჩამონათვალი 6.

#Include. Int main (ბათილად) (int arr \u003d (0); ამისთვის (int i \u003d 0; მე< 100; i = i + 1){ arr[i] = 2*i; } for(int i = 0; i < 100; i = i + 1){ printf("%d\t",arr[i]); } return(0); }

პროგრამაში პირველი ციკლი ინარჩუნებს პირველი ასი ახალგაზრდა ნომრები მასივში, ხოლო მეორე ციკლში აჩვენებს მათ ეკრანზე.

შეიარაღებული ახალი იარაღები, მოდით გადაწეროთ ჩვენი პროგრამა გაკვეთილის დასაწყისიდან ისე, რომ იგი იყენებს მასივის შემთხვევითი რიცხვების შენახვის სტატისტიკას.

ჩამონათვალი 7.

#Include. #Include. #Include. int main (boid) (Srand (დრო (null); int count \u003d (0); int rand_number; for (int i \u003d 0; მე< 100000; i = i + 1){ rand_number = rand()%3; count = count + 1; } for(int i = 0; i < 3; i = i + 1){ printf("%d - %d\n", i, count[i]); } return 0; }

ყურადღება მიაქციეთ მიღებას, რომელიც გამოიყენება ამ პროგრამით.
მასივის ნულოვანი ელემენტის, ნომრის წვეთების რაოდენობა 0 ინახება, პირველ ელემენტში - მეორე ელემენტში 1-ის დეპოზიტების რაოდენობა - ნომერი 2. ანუ, გენერირებული ნომერი თავად საშუალებას გაძლევთ განსაზღვროთ რომელი ელემენტი მასივი თქვენ უნდა დაამატოთ ერთეული. აქედან გამომდინარე, შეცვლა შერჩევის შესახებ განცხადების ქრება. მოსახერხებელი, არა?