Gruntle Software & Testing

By Stewart TristianPosted on Posted in Hagayaasha

Tababarkan qotodheer ee ku saabsan soo noqnoqda ee Java wuxuu ku sharaxayaa waxa ay tahay soo noqnoqoshada oo wata Tusaalayaal, Noocyo, iyo Fikrado la xidhiidha. Waxa kale oo ay dabooshaa Recursion Vs Iteration: >

> Casharradiiyadii hore ee Java, waxaynu ka soo aragnay hab-raac-is-daba-joog ah oo aan ku dhawaaqno loop ka dibna u dhex-maro qaab-dhismeedka xogta iyadoo la raacayo hal element a time.

Waxaan sidoo kale aragnay qulqulka shuruuda ah halkaas oo mar kale aan ku hayno hal wareeg oo doorsoome oo ku celis gabal kood ah ilaa doorsoomaha loop uu buuxiyo shuruudaha. Marka ay timaado wicitaanada shaqada, waxaan sahaminay habka soo noqnoqda ee wicitaanada shaqada sidoo kale.

5> 2> 3> > Casharkan, waxaynu kaga hadli doonaa habab kale oo loo wajaho programming-ka oo ah habka soo noqnoqda > >

Waa maxay Recursion In Java?

Dib-u-soo-noqosho waa hab ay hawl ama hab isku wacaan mar kale iyo mar kale. Shaqadan oo si toos ah ama si aan toos ahayn loogu yeero waxaa loo yaqaan "recursive function"

Waxaan arki doonaa tusaalooyin kala duwan si loo fahmo dib u soo noqoshada. Haddaba aynu aragno habka dib-u-curashada

Recursion Syntax

Habka kasta oo hirgeliya dib-u-celinta waxay leedahay laba qaybood oo aasaasi ah:

  1. Qaabka wacitaanka oo isu yeedhi kara ie. recursive
    2. >
  2. Sharuud horudhac ah oo joojin doonta soo noqoshada jebiyoDib-u-soo-noqoshada markaas waxay sii socon doontaa si aan xad lahayn waxayna keenaysaa qulqulka qulqulka

Qorshaha guud ee soo noqnoqda waa sidan soo socota: 

methodName (T parameters…) { if (precondition == true) //precondition or base condition { return result; } return methodName (T parameters…); //recursive call }

Ogsoonow in shuruudda sidoo kale loo yaqaanno. xaalad salka. Waxaan uga hadli doonaa wax badan oo ku saabsan xaaladda aasaasiga ah ee qaybta soo socota.

Fahamka Dib-u-soo-noqoshada Java

Qaybtan, waxaan isku dayi doonaa inaan fahamno habka dib-u-curashada oo aan aragno sida ay u dhacdo. Waxaan wax ka baran doonaa xaalada salka, qulqulka buuxdhaafka, waxaanan arki doonaa sida dhibaato gaar ah loogu xalin karo soo noqoshada iyo faahfaahinta kale. marka hore bixi xalka kiiska salka. Kadibna waxaynu ku cabirnaa dhibka ka wayn xaga dhibaatooyinka yaryar

Tusaale ahaan waxaynu qaadan karnaa mushkilad caadi ah oo ah xisaabinta qaybinta nambarka. Marka la eego nambar n, waa in aan helnaa qayb ka mid ah n uu tilmaamayo n!

Hadda aan hirgelinno barnaamijka si aan u xisaabino n factorial (n!) annagoo adeegsanayna dib u soo noqoshada.

public class Main{ static int fact(int n) { if (n == 1) // base condition return 1; else return n*fact(n-1); } public static void main(String[] args) { int result = fact(10); System.out.println("10! = " + result); } }

Output

Barnaamijkan waxa aynu ku arki karnaa in xaalada (n=1) ay tahay xaalada aasaasiga ah oo marka xaaladan la gaadho ay shaqadu soo noqoto 1 Qaybta kale ee shaqadu waa wicitaanka soo noqnoqda. Laakiin mar kasta oo habka dib-u-celinta la yiraahdo, n waxaa hoos loo dhigaa 1.

Sidaas darteed waxaan ku soo gabagabeyn karnaa in ugu dambeyntii qiimaha n uu noqon doono 1 ama ka yar 1 iyo tan.dhibic, habka ayaa soo celin doona qiimaha 1. Xaaladdan aasaasiga ah ayaa la gaari doonaa oo shaqadu waa joogsan doontaa. Ogsoonow in qiimaha n uu noqon karo wax kasta ilaa inta ay ku qanacsan tahay xaaladda aasaasiga ah

> 15> Xallinta Dhibaatada Isticmaalka Dib-u-celinta

Fikirka aasaasiga ah ee ka dambeeya isticmaalka dib-u-celinta waa in la muujiyo dhibaatada weyn ee dhinaca dhibaatooyin yaryar. Sidoo kale, waxaan u baahannahay inaan ku darno hal ama dhowr shuruudood oo salka ah si aan uga soo baxno soo noqnoqoshada.

Barnaamijkan, waxaan ku muujinay n factorial (n!) marka loo eego qiyamka yaryar waxaanan lahayn xaalad salka (n =1) si marka n gaaro 1, aan uga baxno habka soo noqnoqda.

Khaladaadka Xad-dhaafka ah ee Soo noqnoqda

>Waxaan la soconnaa in marka hab ama hawl kasta la yeedho, xaaladda shaqadu waxa lagu kaydiyaa xidhmada oo la soo ceshado marka hawshu soo noqoto. Xirmada waxaa loo isticmaalaa habka soo noqnoqda sidoo kale.

Laakin xaaladda soo noqnoqota, dhibaato ayaa dhici karta haddii aynaan qeexin xaaladda aasaasiga ah ama marka xaaladda aasaasiga ah aan la gaarin ama la fulin. Haddii xaaladdani dhacdo markaas waxaa laga yaabaa in qulqulka xad-dhaafka ah uu soo baxo.

Aan tixgelinno tusaalaha hoose ee calaamadaynta.

Halkan waxaan ku siinay shuruud sal khaldan, n==100.

public class Main { static int fact(int n) { if (n == 100) // base condition resulting in stack overflow return 1; else return n*fact(n-1); } public static void main(String[] args) { int result = fact(10); System.out.println("10! = " + result); } }

Markaa n > 100 habka ayaa soo noqon doona 1 laakiin soo noqoshada ma joogsan doonto. Qiimaha n wuxuu ku sii jiri doonaa hoos u dhac aan xad lahayn sida uu jiroShardi kale ma aha in la joojiyo. Tani way sii socon doontaa ilaa ay buuxdhaafto.

> Xaalad kale ayaa noqon doonta marka qiimaha n 100. Xaaladdan oo kale, sidoo kale habka waligiis ma fulin doono shuruudaha aasaasiga ah oo keenaya qulqulka qulqulka

Tusaalooyinka soo noqnoqda ee Java

Qaybtan, waxaan hirgelin doonaa tusaalooyinka soo socda annaga oo adeegsanayna soo noqnoqoshada 34,55,…

Txanaha sare wuxuu muujinayaa in curiyaha hadda jira uu yahay wadarta labadii shay ee hore. Sidoo kale, qaybta ugu horreysa ee taxanaha Fibonacci waa 1.

Marka guud ahaan haddii n uu yahay lambarka hadda jira, ka dibna waxaa lagu bixiyaa wadarta (n-1) iyo (n-2). Sida elementka hadda lagu muujiyay marka la eego walxaha hore, waxaan ku muujin karnaa dhibaatadan iyadoo la adeegsanayo soo noqnoqoshada

Barnaamijka lagu hirgelinayo taxanaha Fibonacci waxaa lagu bixiyaa hoos: > 

public class Main { //method to calculate fibonacci series static int fibonacci(int n) { if (n = 1) { return n; } return fibonacci(n-1) + fibonacci(n-2); } public static void main(String[] args) { int number = 10; //print first 10 numbers of fibonacci series System.out.println ("Fibonacci Series: First 10 numbers:"); for (int i = 1; i = number; i++) { System.out.print(fibonacci(i) + " "); } } }

output

>

> # 2) Hubi haddii nambarku yahay Palindrome Isticmaalka soo noqnoqoshada > Palindrome waa taxane la mid ah marka aan helno u akhri bidix ilaa midig ama midig ilaa bidix.

Marka la eego tirada 121, waxaynu aragnaa marka aynu ka akhrino bidix ilaa midig iyo midigta ilaa bidix inay siman yihiin. Markaa nambarka 121 waa palindrome

Aan soo qaadanno nambar kale, 1242. Markaynu bidix ilaa midig ka akhrino waa 1242, marka midigta laga akhriyona waxa loo akhriyaa 2421. Haddaba kanu maaha palindrome.

Annagahirgali barnaamijka palindrome adiga oo dib u rogaya nambarada nambarada oo si isdaba joog ah u barbar dhig nambarka la bixiyay iyo matalaad kale.

Barnaamijka hoose waxa uu hirgeliyaa barnaamijka si loo hubiyo palindrome-ka. 

import java.io.*; import java.util.*; public class Main { // check if num contains only one digit public static int oneDigit(int num) { if ((num >= 0) && (num  10)) return 1; else return 0; } //palindrome utility function public static int isPalindrome_util (int num, int revNum) throws Exception { // base condition; return if num=0 if (num == 0) { return revNum; } else { //call utility function recursively revNum = isPalindrome_util(num / 10, revNum); } // Check if first digit of num and revNum are equal if (num % 10 == revNum % 10) { // if yes, revNum will move with num return revNum / 10; } else { // exit throw new Exception(); } } //method to check if a given number is palindrome using palindrome utility function public static int isPalindrome(int num) throws Exception { if (num  0) num = (-num); int revNum = (num); return isPalindrome_util(num, revNum); } public static void main(String args[]) { int n = 1242; try { isPalindrome(n); System.out.println("Yes, the given number " + n + " is a palindrome."); } catch (Exception e) { System.out.println("No, the given number " + n + " is not a palindrome."); } n = 1221; try { isPalindrome(n); System.out.println("Yes, the given number " + n + " is a palindrome."); } catch (Exception e) { System.out.println("No, the given number " + n + " is not a palindrome."); } } }
0 Wax soo saarka>

# 3 Xarig natiijadu waa "olleH".

Tani waxaa lagu sameeyaa iyadoo la isticmaalayo dib-u-soo-noqosho. Laga bilaabo jilaha ugu dambeeya ee xargaha waxaan si isdaba joog ah u daabacnaa xaraf kasta ilaa inta ay dhammaan xuruufta xarguhu ka dhammaanayaan.

Wax soo saarka

> > # 4 Algorithm-kan, oo la siiyay noocyo kala duwan oo n element ah, waxaanu ka baadhnay shaxdan curiyaha muhiimka ah ee la bixiyay. Bilawga, waxa aanu u kala qaybinnaa shaxanka laba qaybood annagoo helayna qaybta dhexe ee shaxanka

Markaa waxay ku xidhan tahay in badhtanka furaha aanu xaddidno raadintayada qaybta hore ama labaad ee shaxanka. Sidan oo kale habkan ayaa lagu soo celiyaa ilaa meesha laga helo walxaha muhiimka ah

Waxaan hirgelin doonnaa algorithm-ka annagoo adeegsanayna dib-u-celinta halkan 

import java.util.*; class Binary_Search { // recursive binary search int binarySearch(int numArray[], int left, int right, int key) { if (right >= left) { //calculate mid of the array int mid = left + (right - left) / 2; // if the key is at mid, return mid if (numArray[mid] == key) return mid; // if key  key) return binarySearch(numArray, left, mid - 1, key); // Else recursively search in the right subarray return binarySearch(numArray, mid + 1, right, key); } // no elements in the array, return -1 return -1; } } class Main{ public static void main(String args[]) { Binary_Search ob = new Binary_Search(); //declare and print the array int numArray[] = { 4,6,12,16,22}; System.out.println("The given array : " + Arrays.toString(numArray)); int len = numArray.length; //length of the array int key = 16; //key to be searched int result = ob.binarySearch(numArray, 0, len - 1, key); if (result == -1) System.out.println("Element " + key + " not present"); else System.out.println("Element " + key + " found at index " + result); } }

> Wax soo saar 2>

#5 0> TheBarnaamijka Java si loo helo qiimaha ugu yar ee shaxanka ayaa lagu bixiyaa hoos Tusaalooyinka soo noqnoqda. Marka laga reebo tusaalooyinkan, dhibaatooyin badan oo kale oo software-ka ah ayaa lagu hirgelin karaa iyadoo la adeegsanayo farsamooyinka soo noqnoqda.

Noocyada soo noqnoqda

Habka soo noqnoqda

> Waxay kala yihiin: >

# 1 lagu fuliyo habka dib-u-celinta, waxa loo yaqaan "Recursion Tail". Ereyga guud ee dib u soo noqoshada dabada ayaa lagu bixiyaa hoos: 
methodName ( T parameters…){ { if (base_condition == true) { return result; } return methodName (T parameters …) //tail recursion }

#2) Dib u soo noqoshada madaxa

> Dib u soo noqoshada madaxa waa hab kasta oo soo noqnoqda oo aan ahayn dib u soo noqoshada dabada. Markaa xitaa dib u soo noqoshada guud ayaa ka horeysa dib u soo noqoshada. >

Syntax of head recursion waa sidan soo socota: 

methodName (T parameters…){ if (some_condition == true) { return methodName (T parameters…); } return result; }

Soo noqnoqoshada Vs Iteration In Java

> 24> 25>Soo-noqoshada > >> > > > 27> > >> > Way adag tahay in la saxo oo la ilaaliyo > xaalad aan la cayimin ama lama gaadhin. > 24> >
Iteration
Soo-noqoshada waa hab-raac uu hab-ku-soo-noqnoqod-is-wacyi-ku-soo-noqod-ku-soo-noqnoqod-ku-soo-noq-noqosho-ku-soo-noqnoqod-ku-soo-noqnoqosho-ku-soo-noqno-noqoto-ilaa-iyo-la-soo-jeedin-ku-soo-noqod-ku-soo-noqod-ku-soo-noqod-soo-noqod-ilaa-iyo-la-soo-celin-ku-soo-celinta waa hab lagu soo celceliyo gabal kood ah oo lagu fuliyo dhowr jeer ama inta laga buuxinayo shuruud. loops.
Si fiican ayey ugu shaqaysaaCabbirka koodka yar. Si fiican ugu shaqeeya cabbirka koodka.
Waxay adeegsataa xusuusta dheeraadka ah mar kasta oo soo noqnoqota lagu riixo xidhmada Marka la barbardhigo xusuusta yar Waxaa la isticmaalaa
Way fududahay in la saxo oo la ilaaliyo Waxay ku fulin kartaa wakhti aan xad lahayn laakiin ugu dambayntii waxay joojin doontaa fulinta khalad kasta oo xusuusta
Kakanaanta wakhtiga aad buu u sarreeyaa. Kakanaanta wakhtigu waa mid dhinaca hoose ah.
13

Jawab: Soo noqnoqoshada, hawsha dib-u-soo-celinta ayaa iskeed isu wacaysa si isdaba-joog ah ilaa xaalad salka ku haysa la qanciyo. Xusuusta shaqada loogu yeero waxaa lagu riixaa raso ku taal xagga sare ee xusuusta shaqada wicitaanka. Wicitaan kasta oo hawleed, koobi gooni ah oo doorsoomayaal maxalli ah ayaa la sameeyay Jawaab: Dib-u-soo-noqoshada waxaa loo isticmaalaa in lagu xalliyo dhibaatooyinka kuwaas oo loo kala saari karo kuwa yar yar oo dhibka oo dhan waxaa lagu muujin karaa dhibaato yar.

adag in lagu xalliyo iyadoo la isticmaalayo hab ku celcelin. Marka laga reebo dhibaatooyinka kuwaas oo waqti kakanaanta aysan arintu ahayn, isticmaal dib-u-celinta.

Q #3) Waa maxay faa'iidooyinkaSoo noqoshada

  • Dib-u-soo-celinta waxay noo ogolaanaysaa inaan si fudud u xallinno dhibaatooyinka marka la barbar dhigo habka soo noqnoqda.
    • > Q #4>

    >Jawab: Soo noqnoqda waxay samaysaa wicitaano soo noqnoqda ilaa shaqada saldhiga laga gaadho. Sidaa darteed waxaa jira korka sare ee xusuusta sida xusuusta loogu talagalay wicitaan kasta oo shaqo ah ayaa lagu riixaa xirmada.

    Dhanka kale ma laha wax badan oo xusuusta ah. Fulinta soo noqnoqda ayaa ka gaabis ah habka soo noqnoqda. Dib-u-soo-noqoshada waxay yaraynaysaa cabbirka koodka halka habka soo noqnoqoshada uu ka dhigayo kood weyn.

    Q #5) Waa maxay Faa'iidooyinka soo noqnoqda ee soo noqnoqda?

    Jawab:

    >
    • Dib-u-soo-celinta waxay ka dhigaysaa koodka mid cad oo gaaban. traversals, iwm.
    • Maadaama wicitaan kasta oo shaqo uu leeyahay xusuusta lagu riixo xirmada, Recursion waxay isticmaashaa xusuusta badan> Gabagabo

      Dib-u-curashadu waa fikrad aad muhiim u ah software-ka iyadoon loo eegin luqadda barnaamijka. Dib-u-soo-noqoshada inta badan waxaa loo adeegsadaa xallinta dhibaatooyinka qaab-dhismeedka xogta sida munaaradaha Hanoi, geed-socodka geedaha, liisaska isku xiran, iwm. In kasta oo ay qaadato xusuus badan,Dib-u-soo-noqoshada waxay ka dhigaysaa kood mid fudud oo cad.

      Waxaan ku baadhnay wax walba oo ku saabsan Recursion casharkan. Waxaan sidoo kale hirgelinay tusaalooyin badan oo barnaamijyo ah si loo fahmo fikradda.

    Scroll to top