நிரலாக்கங்களில் வரிசையாக்க முறைகள்: "குமிழி"

ஒரு குமிழியால் வரிசைப்படுத்துவது வேகமான முறையாக மட்டுமே கருதப்படுவதில்லை, மேலும் இது வரிசைப்படுத்தும் மெதுவான வழிகளின் பட்டியலை மூடுகிறது. எனினும், அதன் நன்மைகள் உள்ளன. எனவே, குமிழி முறை மூலம் வரிசைப்படுத்துவது சிக்கலுக்கு மிக தர்க்கரீதியான மற்றும் இயற்கையான தீர்வாகும், நீங்கள் ஒரு குறிப்பிட்ட வரிசையில் கூறுகளை ஏற்பாடு செய்ய வேண்டும். ஒரு சாதாரண மனிதர் உதாரணமாக, கையால் அதை பயன்படுத்தி, வெறுமனே உள்ளுணர்வு மூலம்.

இந்த அசாதாரண பெயர் எங்கிருந்து வந்தது?

நீரில் குமிழிகள் கொண்ட ஒரு ஒப்புமை பயன்படுத்தி முறை பெயர் கண்டுபிடிக்கப்பட்டது. இது ஒரு உருவகம். சிறிய ஏர் குமிழ்கள் மேல் உயரும் போலவே - ஏனெனில் அவர்களின் அடர்த்தி எந்த திரவத்திலிருந்தும் (இந்த விஷயத்தில் - நீர்) அதிகமாக உள்ளது, மற்றும் ஒவ்வொரு உறுப்பு வரிசைக்கும், சிறியது மதிப்புக்குரியது, மேலும் அது படிப்படியாக எண்களின் பட்டியலின் தொடக்கத்திற்கு வழி செய்கிறது.

வழிமுறை விளக்கம்

குமிழி வரிசையாக்கம் பின்வருமாறு செய்யப்படுகிறது:

• முதல் பாஸ்: எண்களின் வரிசையின் கூறுகள் இரண்டு எடுத்து, ஜோடிகளை ஒப்பிடும். இரண்டு கூறுகளில் முதல் மதிப்பு இரண்டாவது விட அதிகமாக இருந்தால், நிரல் இடங்களின் பரிமாற்றத்தை உருவாக்குகிறது;
• எனவே, மிகப்பெரிய எண் வரிசையின் இறுதியில் உள்ளது. மற்ற உறுப்புகள் அனைத்தும் ஒரு குழப்பமான நிலையில் இருப்பதால் மேலும் வரிசையாக்கம் தேவைப்படுகிறது;
• ஆகையால், இரண்டாவது பாஸ் தேவைப்படுகிறது: முன்னரே (ஏற்கெனவே விவரிக்கப்பட்டது) மற்றும் பல ஒப்பீடுகள் - மைனஸ் ஒன்றுடன் ஒப்பிடுவதால் இது தயாரிக்கப்படுகிறது;
• கடந்து செல்லும் போது, மூன்று ஒப்பீடுகள் இரண்டாவது விட குறைவான ஒன்று, மற்றும் இரண்டு விட இன்னும் இரண்டு. அதனால் தான்;
• ஒவ்வொரு பாஸும் (வரிசையில், ஒரு குறிப்பிட்ட எண்) கழித்தல் (பாஸ் எண்ணிக்கை) ஒப்பீடுகள் என்று நாம் சுருக்கமாக கூறுகிறோம்.

எதிர்கால திட்டத்தின் குறுகிய வழிமுறை கூட பின்வருமாறு எழுதப்பட்டுள்ளது:

• இரண்டு எண்களை காணும் வரை எண்களின் வரிசை சோதிக்கப்படும், இதில் இரண்டாவது, முதல் விட அதிகமாக இருக்க வேண்டும்;
• ஒழுங்கின் ஒவ்வொரு மற்ற உறுப்புகளுடனும் தவறாக அமைக்கப்பட்டிருக்கும், நிரல் மாற்றங்கள்.

சூடோக்கோடு விவரிக்கப்பட்ட படிமுறை அடிப்படையில்

எளிய செயல்படுத்த பின்வருமாறு:

செயல்முறை Sortirovka_Puzirkom ;

தொடங்கி

Nachnii_index இலிருந்து j க்கு ஒரு வளையம் konechii_index ;

நான் nachalnii_index முதல் konechii_index-1 க்கு ஒரு வளையம்;

Massiv [i]> massiv [i + 1] (முதல் உறுப்பு இரண்டாவது விட அதிகமாக இருந்தால்), பின்:

(இடங்களில் மதிப்புகளை மாற்றவும்);

முடிவு

நிச்சயமாக, இங்கே எளிமை நிலைமையை மட்டுமே அதிகரிக்கிறது: எளிமையான படிமுறை, இன்னும் அது அனைத்து குறைபாடுகளை காட்டுகிறது. நேரம்-நுகர்வு ஒரு சிறிய வரிசைக்கு கூட மிகப்பெரியது (இங்கே சார்பியல் வருகிறது: சராசரியாக நபர் நேரம் சிறியதாக தோன்றலாம், ஆனால் ப்ரோக்ராமரின் கணக்கு ஒவ்வொரு இரண்டாவது அல்லது மில்லிசெகண்ட்ஸ் கணக்கில்).

இது ஒரு நல்ல செயல்பாட்டை எடுத்தது. உதாரணமாக, சில இடங்களில் வரிசைகளில் மதிப்புகள் பரிமாற்றம் கணக்கில் எடுத்துக்கொள்வது:

செயல்முறை Sortirovka_Puzirkom ;

தொடங்கி

Sortirovka = உண்மை;

சுழற்சியில் sortirovka = உண்மை;

Sortirovka = பொய்;

நான் nachalnii_index முதல் konechii_index-1 க்கு ஒரு வளையம்;

Massiv [i]> massiv [i + 1] (முதல் உறுப்பு இரண்டாவது விட அதிகமாக இருந்தால்), பின்:

(இடங்களில் கூறுகளை நாங்கள் மாற்றுவோம்);

Sortirovka = உண்மை; (பரிமாற்றம் செய்யப்பட்டது என்று குறிக்கப்பட்டது).

இறுதியில்.

முறையின் குறைபாடுகள்

முக்கிய குறைபாடு செயல்முறை காலமாகும். குமிழி வரிசையாக்க நெறிமுறை எவ்வளவு காலம் வேலை செய்கிறது?

மரணதண்டனை எண்களின் எண்ணிக்கையில் சதுரத்திலிருந்து கணக்கிடப்படுகிறது. இறுதி முடிவு விகிதத்தில் உள்ளது.

மிக மோசமான சூழ்நிலையில், வரிசை பல நேரங்களில் குறுக்கிடப்படுகிறது, அதில் உள்ள கூறுகள் உள்ளன, ஒரு மதிப்பு. இறுதியில் இது ஒரு ஒப்பிடக்கூடிய எதுவும் இல்லை ஒரே ஒரு உறுப்பு உள்ளது, மற்றும் வரிசை வழியாக கடந்த பாஸ் ஒரு பயனற்ற நடவடிக்கை ஆகிறது.

கூடுதலாக, எளிய பரிமாற்றங்களால் வரிசையாக்க முறையானது, இது அழைக்கப்படுவதால், சிறிய அளவின் வரிசைகள் மட்டுமே செயல்படுகிறது. பெரிய அளவிலான தரவு அதைப் பயன்படுத்தி செயலாக்க முடியாது: இதன் விளைவாக பிழைகள் அல்லது நிரல் செயலிழப்பு இருக்கும்.

கண்ணியம்

ஒரு குமிழி வரிசைப்படுத்துவது புரிந்து கொள்ள மிகவும் எளிதானது. தொழில்நுட்ப பல்கலைக்கழகங்களின் பாடத்திட்டத்தில், வரிசைகளின் கூறுகளை வரிசைப்படுத்தும் போது, அது முதலில் செல்கிறது. இந்த முறையை டெல்பி நிரலாக்க மொழி (டி (டெலிஃபி) மற்றும் சி / சி ++ (சி / சி பிளஸ் பிளஸ்)), சரியான வரிசையில் மதிப்புகள் மற்றும் பாஸ்கல் (பாஸ்கல்) ஆகியவற்றிற்காக ஒரு நம்பமுடியாத எளிமையான வழிமுறையாகும்.

குறைபாடுகள் காரணமாக, வழிமுறை சாராத காரணங்களுக்காக பயன்படுத்தப்படவில்லை.

வரிசையாக்க ஒரு தெளிவான கொள்கை

வரிசையின் தொடக்க காட்சி 8 22 4 74 44 37 1 7

படி 1 8 22 4 74 44 37 1 7

8 22 4 74 44 1 37 7

8 22 4 74 1 44 37 7

8 22 4 1 74 44 37 7

8 22 1 4 74 44 37 7

8 1 22 4 74 44 37 7

1 8 22 4 74 44 37 7

படி 2 1 8 22 4 74 44 7 37

1 8 22 4 74 7 44 37

1 8 22 4 7 74 44 37

1 8 22 4 7 74 44 37

1 8 4 22 7 74 44 37

1 4 8 22 7 74 44 37

படி 3 1 4 8 22 7 74 37 44

1 4 8 22 7 37 74 44

1 4 8 22 7 37 74 44

1 4 8 7 22 37 74 44

1 4 7 8 22 37 74 44

படி 4 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

படி 5 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

படி 6 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

படி 7 1 4 7 8 22 37 44 74

பாஸ்கல் ஒரு குமிழி மூலம் வரிசையாக்க உதாரணம்

உதாரணம்:

Const kol_mas = 10;

Var massiv: வரிசை [1..kol_mas] முழு எண்;

A, b, k: முழு எண்;

தொடங்கும்

Writeln ('உள்ளீடு', kol_mas, 'வரிசைகளின் கூறுகள்');

ஒரு: 1 க்கு kol_mas செய்ய readln (massiv [a]);

ஒரு: kol_mas-1 க்கு 1 = தொடங்கும்

B: = a + 1 க்கு kol_mas செய்ய ஆரம்பிக்க

Massiv [a]> massiv [b] பின்னர் தொடங்கும்

K: = massiv [a]; Massiv [a]: = massiv [b]; Massiv [b]: = k;

முடிவுக்கு;

முடிவுக்கு;

முடிவுக்கு;

ரைட்லென் ('வகைக்கு பிறகு');

ஒரு: = 1 முதல் kol_mas to writeln (massiv [a]);

இறுதியில்.

C (C) இல் ஒரு குமிழி மூலம் வரிசைப்படுத்துவதற்கான எடுத்துக்காட்டு

உதாரணம்:

# அடங்கும்

# அடங்கும்

Int main (எண்ணாக argc, char * argv [])

{

Int massiv [8] = {36, 697, 73, 82, 68, 12, 183, 88}, நான், ff;

(;;;;;;;;;

Ff = 0;

(I = 7; i> 0; i -) {

(Massiv [i]

இடமாற்று (massiv [i], massiv [i-1]);

Ff ++;

}

}

(Ff == 0) முறிந்தால்;

}

Getch (); // திரை தாமதம்

Return 0;

}.