რეკურსიის თანამედროვე გაგება: ფუნქციის განსაზღვრა და მასზე წვდომა გარედან და ამ ფუნქციონალიდან. ითვლება, რომ რეკურსია მათემატიკოსებმა დაბადეს: ფაქტორული გამოთვლა, უსასრულო სერიები, ფრაქტალები, გაგრძელებული წილადები… თუმცა, რეკურსიის ნახვა ყველგან შეიძლება. ობიექტური ბუნებრივი კანონები რეკურსიას თავის მთავარ ალგორითმად და გამოხატვის (არსებობის) ფორმად „განიხილავს“არა იმდენად მატერიალური სამყაროს ობიექტებს, არამედ ზოგადად მოძრაობის მთავარ ალგორითმს.
სხვადასხვა სპეციალობის ადამიანები მეცნიერებისა და ტექნოლოგიების სხვადასხვა დარგში იყენებენ რეკურსიულ ალგორითმს f (x), სადაც "x ~/=f (x)". ფუნქცია, რომელიც საკუთარ თავს უწოდებს, ძლიერი გადაწყვეტაა, მაგრამ ამ ამოხსნის ჩამოყალიბება და გაგება, უმეტეს შემთხვევაში, ძალიან რთული ამოცანაა.
ძველ დროში რეკურსიას იყენებდნენ სასახლის სივრცის გასაზრდელად. ერთმანეთისკენ მიმართული სარკეების სისტემის მეშვეობით თქვენ შეგიძლიათ შექმნათ განსაცვიფრებელი სამგანზომილებიანი სივრცითი ეფექტები. მაგრამ ასე ადვილია იმის გაგება, თუ როგორდაარეგულირე ეს სარკეები? კიდევ უფრო რთულია იმის დადგენა, თუ სად არის სივრცეში წერტილი, რომელიც აისახება რამდენიმე სარკეში.
რეკურსია, რეკურსიული ალგორითმები: მნიშვნელობა და სინტაქსი
პრობლემა, რომელიც ჩამოყალიბებულია მოქმედებების თანმიმდევრობის გამეორებით, შეიძლება გადაწყდეს რეკურსიულად. მარტივი ალგორითმი (კვადრატული განტოლების გამოთვლა, სკრიპტი ვებ გვერდის ინფორმაციით შევსების მიზნით, ფაილის წაკითხვა, შეტყობინების გაგზავნა…) არ საჭიროებს რეკურსიას.
ძირითადი განსხვავებები ალგორითმში, რომელიც იძლევა რეკურსიული ამოხსნის საშუალებას:
- არის ალგორითმი, რომელიც უნდა შესრულდეს რამდენჯერმე;
- ალგორითმს სჭირდება მონაცემები, რომლებიც ყოველ ჯერზე იცვლება;
- ალგორითმი არ უნდა შეიცვალოს ყოველ ჯერზე;
- არის საბოლოო პირობა: ალგორითმი არის რეკურსიული - არა უსასრულო.
ზოგადად, არ შეიძლება იმის მტკიცება, რომ ერთჯერადი შესრულება არის აუცილებელი პირობა რეკურსიის მიზეზის არარსებობისთვის. თქვენ ასევე არ შეგიძლიათ მოითხოვოთ სავალდებულო საბოლოო პირობა: უსასრულო რეკურსიებს აქვთ საკუთარი ფარგლები.
ალგორითმი რეკურსიულია: როდესაც ოპერაციების თანმიმდევრობა განმეორებით სრულდება, მონაცემებზე, რომლებიც ყოველ ჯერზე იცვლება და ყოველ ჯერზე იძლევა ახალ შედეგს.
რეკურსიის ფორმულა
რეკურსიის მათემატიკური გაგება და მისი ანალოგი პროგრამირებაში განსხვავებულია. მათემატიკა, მართალია პროგრამირების ნიშნები არსებობს, მაგრამ პროგრამირება გაცილებით მაღალი დონის მათემატიკაა.
კარგად დაწერილი ალგორითმი ჰგავს მისი ავტორის ინტელექტის სარკეს. გენერალირეკურსიის ფორმულა პროგრამირებაში არის "f(x)", სადაც "x ~/=f(x)" აქვს მინიმუმ ორი ინტერპრეტაცია. აქ "~" არის შედეგის მსგავსება ან არარსებობა, ხოლო "=" არის ფუნქციის შედეგის არსებობა.
პირველი ვარიანტი: მონაცემთა დინამიკა.
- ფუნქცია "f(x)" აქვს რეკურსიული და უცვლელი ალგორითმი;
- "x" და შედეგს "f(x)" აქვს ყოველ ჯერზე ახალი მნიშვნელობები, შედეგი "f(x)" არის ამ ფუნქციის ახალი "x" პარამეტრი.
მეორე ვარიანტი: კოდის დინამიკა.
- ფუნქცია "f(x)" აქვს რამდენიმე ალგორითმი, რომელიც აზუსტებს (აანალიზებს) მონაცემებს;
- მონაცემთა ანალიზი - კოდის ერთი ნაწილი და რეკურსიული ალგორითმის დანერგვა, რომელიც ასრულებს სასურველ მოქმედებას - კოდის მეორე ნაწილი;
- "f(x)" ფუნქციის შედეგი არ არის.
შედეგი არ არის ნორმალური. პროგრამირება არ არის მათემატიკა, აქ შედეგი არ უნდა იყოს აშკარად წარმოდგენილი. რეკურსიულ ფუნქციას უბრალოდ შეუძლია საიტების გაანალიზება და მონაცემთა ბაზის შევსება, ან ობიექტების ინსტალაცია შემომავალი შეყვანის მიხედვით.
მონაცემები და რეკურსია
რეკურსიული ალგორითმების დაპროგრამება არ არის ფაქტორების გამოთვლა, რომელშიც ფუნქცია ყოველ ჯერზე იღებს მოცემულ მნიშვნელობას, რომელიც არის ერთზე მეტი ან ნაკლები - განხორციელების ვარიანტი დამოკიდებულია დეველოპერის უპირატესობაზე.
მნიშვნელობა არ აქვს, რამდენად ფაქტორული "8!",ალგორითმი, რომელიც მკაცრად მიჰყვება ამ ფორმულას.
ინფორმაციის დამუშავება სულ სხვა რიგის "მათემატიკაა". რეკურსიული ფუნქციები და ალგორითმები აქ მოქმედებს ასოებზე, სიტყვებზე, ფრაზებზე, წინადადებებსა და აბზაცებზე. ყოველი შემდეგი დონე იყენებს წინას.
შეყვანის მონაცემთა ნაკადი გაანალიზებულია პირობების ფართო სპექტრში, მაგრამ ანალიზის პროცესი ძირითადად რეკურსიულია. აზრი არ აქვს უნიკალური ალგორითმების დაწერას შეყვანის ნაკადის ყველა ვარიანტისთვის. ერთი ფუნქცია უნდა იყოს. აქ, რეკურსიული ალგორითმები არის მაგალითები იმისა, თუ როგორ უნდა ჩამოყალიბდეს გამომავალი ნაკადი, რომელიც ადეკვატურია შეყვანისთვის. ეს არ არის რეკურსიული ალგორითმის გამოსავალი, მაგრამ ეს არის სასურველი და აუცილებელი გამოსავალი.
აბსტრაქცია, რეკურსია და OOP
ობიექტზე ორიენტირებული პროგრამირება (OOP) და რეკურსია ფუნდამენტურად განსხვავებული ერთეულებია, მაგრამ ისინი სრულყოფილად ავსებენ ერთმანეთს. აბსტრაქციას არავითარი კავშირი არ აქვს რეკურსიასთან, მაგრამ OOP-ის ლინზიდან ის ქმნის კონტექსტუალური რეკურსიის განხორციელების შესაძლებლობას.
მაგალითად, ინფორმაციის გაანალიზება ხდება და ასოები, სიტყვები, ფრაზები, წინადადებები და აბზაცები ცალკე მონიშნულია. ცხადია, დეველოპერი უზრუნველყოფს ამ ხუთი ტიპის ობიექტების ინსტანციების შექმნას და შესთავაზებს რეკურსიული ალგორითმების გადაწყვეტას თითოეულ დონეზე.
ამავდროულად, თუ ასოების დონეზე „აზრის ძიებას აზრი არ აქვს“, მაშინ სიტყვების დონეზე ჩნდება სემანტიკა. შეგიძლიათ სიტყვები დაყოთ ზმნებებად, არსებით სახელებად, ზმნიზედებად, წინადადებებად… შეგიძლიათ უფრო შორს წახვიდეთ და განსაზღვროთ შემთხვევები.
ფრაზის დონეზე სემანტიკას ავსებენ სასვენი ნიშნები და ლოგიკასიტყვების კომბინაციები. წინადადებების დონეზე გვხვდება სემანტიკის უფრო სრულყოფილი დონე და აბზაცი შეიძლება ჩაითვალოს სრულ აზრად.
ობიექტზე ორიენტირებული განვითარება წინასწარ განსაზღვრავს თვისებებისა და მეთოდების მემკვიდრეობას და გვთავაზობს ობიექტების იერარქიის დაწყებას სრულიად აბსტრაქტული წინაპრის შექმნით. ამავდროულად, ეჭვგარეშეა, რომ თითოეული შთამომავლის ანალიზი რეკურსიული იქნება და ტექნიკურ დონეზე ზედმეტად არ განსხვავდება ბევრ პოზიციაში (ასოები, სიტყვები, ფრაზები და წინადადებები). აბზაცები, ისევე როგორც სრული აზრები, შეიძლება გამოირჩეოდეს ამ სიიდან, მაგრამ ისინი არ არიან არსი.
მნიშვნელოვანია, რომ ალგორითმის დიდი ნაწილი შეიძლება ჩამოყალიბდეს აბსტრაქტულ წინაპართა დონეზე, დაიხვეწოს იგი თითოეული შთამომავლის დონეზე აბსტრაქტული დონიდან მოწოდებული მონაცემებითა და მეთოდებით. ამ კონტექსტში, აბსტრაქცია ხსნის ახალ ჰორიზონტს რეკურსიისთვის.
OOP-ის ისტორიული მახასიათებლები
OOP ორჯერ მოვიდა პროგრამული უზრუნველყოფის სამყაროში, თუმცა ზოგიერთმა ექსპერტმა შეიძლება გამოყოს ღრუბლოვანი გამოთვლის და თანამედროვე იდეების გაჩენა ობიექტებისა და კლასების შესახებ, როგორც ახალი რაუნდი IT ტექნოლოგიების განვითარებაში.
ტერმინები "ობიექტი" და "ობიექტი" OOP-ის თანამედროვე კონტექსტში ჩვეულებრივ მიეკუთვნება გასული საუკუნის 50-60-იან წლებს, მაგრამ ისინი დაკავშირებულია 1965 წელთან და Simula, Lisp, Algol, Smalltalk-ის გაჩენასთან..
იმ დღეებში პროგრამირება არ იყო განსაკუთრებით განვითარებული და ვერ ადეკვატურად პასუხობდა რევოლუციურ კონცეფციებს. იდეებისა და პროგრამირების სტილის ბრძოლა (C/C ++ და პასკალი - ძირითადად) ჯერ კიდევ შორს იყო და მონაცემთა ბაზები ჯერ კიდევ კონცეპტუალურად იყო ჩამოყალიბებული.
80-იანი წლების ბოლოს და 90-იანი წლების დასაწყისში, ობიექტები გამოჩნდა პასკალში და ყველას ახსოვდა კლასები C/C ++ - ამან აღნიშნა OOP-ისადმი ინტერესის ახალი რაუნდი და სწორედ მაშინ გახდა ინსტრუმენტები, ძირითადად პროგრამირების ენები. მხარი დაუჭირეთ მხოლოდ ობიექტზე ორიენტირებულ იდეებს, მაგრამ შესაბამისად განვითარდით.
რა თქმა უნდა, თუ ადრე რეკურსიული ალგორითმები მხოლოდ პროგრამის ზოგად კოდში გამოყენებული ფუნქციები იყო, ახლა რეკურსია შეიძლება გახდეს ობიექტის (კლასის) თვისებების ნაწილი, რაც იძლევა საინტერესო შესაძლებლობებს მემკვიდრეობის კონტექსტში.
თანამედროვე OOP-ის თვისება
OOP-ის შემუშავებამ თავდაპირველად გამოაცხადა ობიექტები (კლასები), როგორც მონაცემებისა და თვისებების კოლექციები (მეთოდები). სინამდვილეში, საუბარი იყო მონაცემებზე, რომლებსაც აქვთ სინტაქსი და მნიშვნელობა. მაგრამ მაშინ შეუძლებელი იყო OOP-ის წარმოდგენა, როგორც რეალური ობიექტების მართვის ინსტრუმენტი.
OOP გახდა ინსტრუმენტი "კომპიუტერული ბუნების" ობიექტების მართვისთვის. სკრიპტი, ღილაკი, მენიუს ელემენტი, მენიუს ზოლი, ტეგი ბრაუზერის ფანჯარაში არის ობიექტი. მაგრამ არა მანქანა, საკვები პროდუქტი, სიტყვა ან წინადადება. რეალური ობიექტები დარჩა ობიექტზე ორიენტირებული პროგრამირების მიღმა და კომპიუტერულმა ინსტრუმენტებმა ახალი ინკარნაცია მიიღო.
პოპულარულ პროგრამირების ენებში განსხვავებების გამო, OOP-ის მრავალი დიალექტი გაჩნდა. სემანტიკის თვალსაზრისით, ისინი პრაქტიკულად ეკვივალენტურია და მათი ფოკუსირება ინსტრუმენტულ სფეროზე და არა გამოყენებაზე, შესაძლებელს ხდის რეალური ობიექტების აღწერის მიღმა აყვანას.ალგორითმები და უზრუნველყოს მათი პლატფორმა და ენათაშორისი "არსებობა".
სტაკები და ფუნქციების გამოძახების მექანიზმები
ფუნქციების (პროცედურების, ალგორითმების) გამოძახების მექანიზმები მოითხოვს მონაცემების (პარამეტრების) გადაცემას, შედეგის დაბრუნებას და ოპერატორის მისამართის დამახსოვრებას, რომელმაც უნდა მიიღოს კონტროლი ფუნქციის (პროცედურის) დასრულების შემდეგ.
ჩვეულებრივ, სტეკი გამოიყენება ამ მიზნით, თუმცა პროგრამირების ენებს ან თავად დეველოპერს შეუძლია უზრუნველყოს კონტროლის გადაცემის სხვადასხვა ვარიანტი. თანამედროვე პროგრამირება აღიარებს, რომ ფუნქციის სახელი შეიძლება იყოს არა მხოლოდ პარამეტრი: ის შეიძლება ჩამოყალიბდეს ალგორითმის შესრულების დროს. ალგორითმი ასევე შეიძლება შეიქმნას სხვა ალგორითმის შესრულებისას.
რეკურსიული ალგორითმების ცნება, როდესაც მათი სახელები და სხეულები შეიძლება განისაზღვროს დავალების ფორმირების დროს (სასურველი ალგორითმის არჩევა), ავრცელებს რეკურსიულობას არა მხოლოდ იმაზე, თუ როგორ უნდა გააკეთოს რამე, არამედ ზუსტად ვინ უნდა გააკეთოს. გააკეთე. ალგორითმის „მნიშვნელოვანი“სახელის არჩევა პერსპექტიულია, მაგრამ ქმნის სირთულეებს.
რეკურსიურობა ფუნქციების სიმრავლეზე
ვერ იტყვით, რომ ალგორითმი რეკურსიულია, როცა ის თავის თავს იძახის და ეს არის. პროგრამირება არ არის დოგმა, და რეკურსიულობის კონცეფცია არ არის ექსკლუზიური მოთხოვნა, რომ გამოიძახოთ საკუთარი თავი საკუთარი ალგორითმის სხეულიდან.
პრაქტიკული აპლიკაციები ყოველთვის არ იძლევა სუფთა ხსნარს. ხშირად, საწყისი მონაცემები უნდა მომზადდეს და რეკურსიული ზარის შედეგი უნდა გაანალიზდეს მთელი პრობლემის კონტექსტში (მთელი ალგორითმი)მთლიანობაში.
ფაქტობრივად, არა მხოლოდ რეკურსიული ფუნქციის გამოძახებამდე, არამედ მისი დასრულების შემდეგაც შეიძლება ან უნდა გამოიძახონ სხვა პროგრამა. თუ გამოძახებასთან დაკავშირებით განსაკუთრებული პრობლემები არ არის: რეკურსიული ფუნქცია A() უწოდებს ფუნქციას B(), რომელიც აკეთებს რაღაცას და უწოდებს A(-ს), მაშინვე ჩნდება პრობლემა კონტროლის დაბრუნებისას. რეკურსიული ზარის დასრულების შემდეგ, A() ფუნქციამ უნდა მიიღოს კონტროლი, რათა ხელახლა გამოიძახოს B(), რომელიც კვლავ გამოიძახებს მას. კონტროლის დაბრუნება ისე, როგორც ეს უნდა იყოს დასტაზე B()-ზე, არასწორი გამოსავალია.
პროგრამისტი არ არის შეზღუდული პარამეტრების არჩევაში და შეუძლია შეავსოს ისინი ფუნქციების სახელებით. სხვა სიტყვებით რომ ვთქვათ, იდეალური გადაწყვეტა არის B()-ის სახელის A()-ს გადაცემა და თავად A()-ს ვუწოდოთ B(). ამ შემთხვევაში კონტროლის დაბრუნების პრობლემა არ იქნება და რეკურსიული ალგორითმის დანერგვა უფრო გამჭვირვალე იქნება.
გაგება და რეკურსიის დონე
პრობლემა რეკურსიული ალგორითმების შემუშავებისას არის ის, რომ თქვენ უნდა გესმოდეთ პროცესის დინამიკა. ობიექტის მეთოდებში რეკურსიის გამოყენებისას, განსაკუთრებით აბსტრაქტული წინაპრის დონეზე, არსებობს საკუთარი ალგორითმის გაგების პრობლემა მისი შესრულების დროის კონტექსტში.
ამჟამად, არ არსებობს შეზღუდვები ფუნქციების დაწყობის დონეზე და დაწყობის სიმძლავრეზე გამოძახების მექანიზმებში, მაგრამ არსებობს გაგების პრობლემა: დროის რომელ მომენტში მონაცემთა რომელ დონეს ან ზოგად ალგორითმში რომელ ადგილს უწოდებენ რეკურსიულს. ფუნქცია და რა რაოდენობის ზარებია თავად.
არსებული გამართვის ხელსაწყოები ხშირად უძლურიაუთხარი პროგრამისტს სწორი გამოსავალი.
მარყუჟები და რეკურსია
მიჩნეულია, რომ ციკლური შესრულება რეკურსიის ტოლფასია. მართლაც, ზოგიერთ შემთხვევაში, რეკურსიული ალგორითმი შეიძლება განხორციელდეს პირობითი და ციკლური კონსტრუქციების სინტაქსში.
თუმცა, თუ არსებობს მკაფიო გაგება, რომ კონკრეტული ფუნქცია უნდა განხორციელდეს რეკურსიული ალგორითმის მეშვეობით, ციკლის ან პირობითი განცხადებების ნებისმიერი გარე გამოყენება უნდა იყოს მიტოვებული.
მნიშვნელობა აქ არის ის, რომ რეკურსიული ამოხსნა ფუნქციის სახით, რომელიც იყენებს თავის თავს, იქნება სრული, ფუნქციურად სრული ალგორითმი. ეს ალგორითმი პროგრამისტისგან მოითხოვს, რომ შექმნას იგი ძალისხმევით, გაიგოს ალგორითმის დინამიკა, მაგრამ ეს იქნება საბოლოო გამოსავალი, რომელიც არ საჭიროებს გარე კონტროლს.
გარე პირობითი და ციკლური ოპერატორების ნებისმიერი კომბინაცია არ მოგვცემს საშუალებას წარმოვადგინოთ რეკურსიული ალგორითმი, როგორც სრული ფუნქცია.
რეკურსიის კონსენსუსი და OOP
რეკურსიული ალგორითმის შემუშავების თითქმის ყველა ვარიანტში ჩნდება ორი ალგორითმის შემუშავების გეგმა. პირველი ალგორითმი ქმნის მომავალი ობიექტების სიას (მაგალითები), ხოლო მეორე ალგორითმი რეალურად არის რეკურსიული ფუნქცია.
საუკეთესო გამოსავალი იქნება რეკურსიის მოწყობა, როგორც ერთი თვისება (მეთოდი), რომელიც რეალურად შეიცავს რეკურსიულ ალგორითმს და ყველა მოსამზადებელი სამუშაოს ჩადება ობიექტის კონსტრუქტორში.
რეკურსიული ალგორითმი იქნება სწორი გამოსავალი მხოლოდ მაშინ, როცა ის მუშაობსმხოლოდ თვითონ, გარე კონტროლისა და მართვის გარეშე. გარე ალგორითმს შეუძლია მხოლოდ მუშაობის სიგნალის მიცემა. ამ სამუშაოს შედეგი უნდა იყოს მოსალოდნელი გამოსავალი, გარე მხარდაჭერის გარეშე.
რეკურსია ყოველთვის უნდა იყოს სრული დამოუკიდებელი გადაწყვეტა.
ინტუიციური გაგება და ფუნქციონალური სისრულე
როდესაც ობიექტზე ორიენტირებული პროგრამირება გახდა დე ფაქტო სტანდარტი, აშკარა გახდა, რომ ეფექტური კოდირებისთვის, თქვენ უნდა შეცვალოთ საკუთარი აზროვნება. პროგრამისტი ალგორითმის შესრულებისას ენის სინტაქსიდან და სემანტიკიდან უნდა გადავიდეს სემანტიკის დინამიკაზე.
რეკურსიის მახასიათებელი: მისი გამოყენება ყველაფერზე შეიძლება:
- ვებების გახეხვა;
- ძიების ოპერაციები;
- ტექსტური ინფორმაციის გარჩევა;
- კითხვა ან შექმნა MS Word დოკუმენტები;
- ტეგების შერჩევა ან ანალიზი…
OOP-ის მახასიათებელი: ის შესაძლებელს ხდის რეკურსიული ალგორითმის აღწერას აბსტრაქტული წინაპრის დონეზე, მაგრამ ითვალისწინებს უნიკალურ შთამომავლებს, რომელთაგან თითოეულს აქვს მონაცემთა და თვისებების საკუთარი პალიტრა.
რეკურსია იდეალურია, რადგან ის მოითხოვს მისი ალგორითმის ფუნქციურ სისრულეს. OOP აუმჯობესებს რეკურსიული ალგორითმის მუშაობას ყველა უნიკალურ ბავშვზე წვდომის მინიჭებით.
