ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ ಸಾರ್ಟಿಂಗ್ ವಿಧಾನಗಳು: "ಬಬಲ್" ಮೂಲಕ ಸಾರ್ಟಿಂಗ್

ಬಬಲ್ನಿಂದ ಸಾರ್ಟಿಂಗ್ ಮಾಡುವುದು ಅತಿವೇಗದ ವಿಧಾನ ಎಂದು ಪರಿಗಣಿಸುವುದಿಲ್ಲ, ಅಲ್ಲದೆ, ಆದೇಶದ ನಿಧಾನವಾದ ವಿಧಾನಗಳ ಪಟ್ಟಿಯನ್ನು ಅದು ಮುಚ್ಚುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದು ಅದರ ಪ್ರಯೋಜನಗಳನ್ನು ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ, ಬಬಲ್ ವಿಧಾನದಿಂದ ಬೇರ್ಪಡಿಸುವುದು ಸಮಸ್ಯೆಗೆ ತಾರ್ಕಿಕ ಮತ್ತು ನೈಸರ್ಗಿಕ ಪರಿಹಾರವಾಗಿದೆ, ನೀವು ನಿರ್ದಿಷ್ಟ ಕ್ರಮದಲ್ಲಿ ಅಂಶಗಳನ್ನು ಜೋಡಿಸಬೇಕಾದರೆ. ಒಂದು ಸಾಮಾನ್ಯ ವ್ಯಕ್ತಿ, ಉದಾಹರಣೆಗೆ, ಕೈಯಿಂದ ಅದನ್ನು ಸರಳವಾಗಿ ಅಂತರ್ಜ್ಞಾನದಿಂದ ಬಳಸುತ್ತಾರೆ.

ಈ ಅಸಾಮಾನ್ಯ ಹೆಸರು ಎಲ್ಲಿಂದ ಬಂದಿತು?

ನೀರಿನಲ್ಲಿ ಗಾಳಿಯ ಗುಳ್ಳೆಗಳೊಂದಿಗೆ ಸಾದೃಶ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ವಿಧಾನದ ಹೆಸರನ್ನು ಕಂಡುಹಿಡಿಯಲಾಯಿತು. ಇದು ರೂಪಕವಾಗಿದೆ. ಸಣ್ಣ ಗಾಳಿ ಗುಳ್ಳೆಗಳು ಮೇಲ್ಭಾಗಕ್ಕೆ ಏರಿದಂತೆ - ಅವುಗಳ ಸಾಂದ್ರತೆಯು ಯಾವುದೇ ದ್ರವಕ್ಕಿಂತಲೂ (ಈ ಸಂದರ್ಭದಲ್ಲಿ - ನೀರು) ಹೆಚ್ಚು, ಮತ್ತು ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶವೂ ಚಿಕ್ಕದು ಮೌಲ್ಯದಲ್ಲಿರುತ್ತದೆ, ಹೆಚ್ಚು ಕ್ರಮೇಣ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯ ಪ್ರಾರಂಭಕ್ಕೆ ದಾರಿ ಮಾಡಿಕೊಡುತ್ತದೆ.

ಅಲ್ಗಾರಿದಮ್ನ ವಿವರಣೆ

ಬಬಲ್ ವಿಂಗಡಣೆಯನ್ನು ಈ ರೀತಿ ನಿರ್ವಹಿಸಲಾಗಿದೆ:

• ಮೊದಲ ಪಾಸ್: ಸಂಖ್ಯೆಗಳ ಸರಣಿಗಳ ಅಂಶಗಳನ್ನು ಎರಡು ರೂಪದಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ ಮತ್ತು ಜೋಡಿಯಾಗಿ ಕೂಡ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಕೆಲವು ಅಂಶಗಳಲ್ಲಿ ಎರಡನೆಯದರಲ್ಲಿ ಮೊದಲ ಮೌಲ್ಯವು ಹೆಚ್ಚಾಗಿದ್ದರೆ, ಪ್ರೋಗ್ರಾಂ ಸ್ಥಳಗಳ ವಿನಿಮಯವನ್ನು ಮಾಡುತ್ತದೆ;
• ಆದ್ದರಿಂದ, ಅತಿದೊಡ್ಡ ಸಂಖ್ಯೆ ರಚನೆಯ ಅಂತ್ಯದಲ್ಲಿದೆ. ಎಲ್ಲಾ ಇತರ ಅಂಶಗಳು ಅವರು ಇದ್ದಂತೆ, ಅಸ್ತವ್ಯಸ್ತವಾಗಿರುವ ಕ್ರಮದಲ್ಲಿ ಉಳಿದಿವೆ ಮತ್ತು ಮತ್ತಷ್ಟು ಬೇರ್ಪಡಿಸುವ ಅಗತ್ಯವಿರುತ್ತದೆ;
• ಆದ್ದರಿಂದ, ಎರಡನೇ ಪಾಸ್ ಅಗತ್ಯವಿರುತ್ತದೆ: ಇದು ಹಿಂದಿನ ಒಂದು (ಈಗಾಗಲೇ ವಿವರಿಸಲಾಗಿದೆ) ಸಾದೃಶ್ಯದಿಂದ ಉತ್ಪತ್ತಿಯಾಗುತ್ತದೆ ಮತ್ತು ಅನೇಕ ಹೋಲಿಕೆಗಳನ್ನು ಹೊಂದಿದೆ - ಮೈನಸ್ ಒನ್;
• ಪಾಸ್ನಲ್ಲಿ, ಮೂರು ಹೋಲಿಕೆಗಳನ್ನು ಎರಡನೆಯದರಲ್ಲಿ ಕಡಿಮೆ, ಮತ್ತು ಎರಡನೆಯದು ಮೊದಲನೆಯದು. ಹೀಗೆ;
• ಪ್ರತಿ ಪಾಸ್ನ (ಸರಣಿ, ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯಲ್ಲಿ) ಮೈನಸ್ (ಪಾಸ್ಗಳ ಸಂಖ್ಯೆ) ಹೋಲಿಕೆಗಳನ್ನು ಹೊಂದಿದೆ ಎಂದು ನಾವು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸುತ್ತೇವೆ.

ಭವಿಷ್ಯದ ಕಾರ್ಯಕ್ರಮದ ಕಡಿಮೆ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಬರೆಯಬಹುದು:

• ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವವರೆಗೆ ಸಂಖ್ಯೆಗಳ ರಚನೆಯು ಪರೀಕ್ಷಿಸಲ್ಪಡುತ್ತದೆ, ಅದರಲ್ಲಿ ಎರಡನೆಯದು ಮೊದಲನೆಯದುಗಿಂತ ಹೆಚ್ಚಿನದಾಗಿರಬೇಕು;
• ಸರಣಿಗಳ ಪರಸ್ಪರ ಅಂಶಗಳಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ತಪ್ಪಾಗಿ ಇದೆ, ಪ್ರೋಗ್ರಾಂ ವಿನಿಮಯಗಳು.

ವಿವರಿಸಿದ ಕ್ರಮಾವಳಿಯ ಆಧಾರದ ಮೇಲೆ ಸೂಡೊಕೋಡ್

ಸರಳ ಅನುಷ್ಠಾನವು ಕೆಳಕಂಡಂತಿದೆ:

ವಿಧಿವಿಧಾನ ವಿಂಗಡಣೆ ವಿಂಗಡಣೆ

ಪ್ರಾರಂಭಿಸಿ

Nachalnii_index ನಿಂದ konechii_index ಗೆ j ಗೆ ಒಂದು ಲೂಪ್;

Nachalnii_index ನಿಂದ konechii_index-1 ಗೆ ನಾನು ಒಂದು ಲೂಪ್;

Massiv [i]> massiv [i + 1] (ಮೊದಲ ಅಂಶವು ಎರಡಕ್ಕಿಂತಲೂ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ), ಆಗ:

(ಸ್ಥಳಗಳಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಿ);

ಅಂತ್ಯ

ಸಹಜವಾಗಿ, ಇಲ್ಲಿ ಸರಳತೆ ಕೇವಲ ಪರಿಸ್ಥಿತಿಯನ್ನು ಉಲ್ಬಣಗೊಳಿಸುತ್ತದೆ: ಸರಳವಾದ ಕ್ರಮಾವಳಿ, ಎಲ್ಲ ನ್ಯೂನತೆಗಳನ್ನು ತೋರಿಸುತ್ತದೆ. ಒಂದು ಸಣ್ಣ ಶ್ರೇಣಿಯನ್ನು (ಇಲ್ಲಿ ಸಾಪೇಕ್ಷತೆಯು ಬರುತ್ತದೆ: ಸರಾಸರಿ ವ್ಯಕ್ತಿಗೆ ಸಮಯದ ಪ್ರಮಾಣವು ಸಣ್ಣದಾಗಿರಬಹುದು, ಆದರೆ ಪ್ರೋಗ್ರಾಮರ್ನಲ್ಲಿ ಖಾತೆಯಲ್ಲಿ ಪ್ರತಿ ಎರಡನೇ ಅಥವಾ ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ) ಸಮಯ-ಸೇವನೆಯು ತುಂಬಾ ಉತ್ತಮವಾಗಿರುತ್ತದೆ.

ಇದು ಉತ್ತಮ ಅನುಷ್ಠಾನವನ್ನು ತೆಗೆದುಕೊಂಡಿತು. ಉದಾಹರಣೆಗೆ, ಕೆಲವು ಸ್ಥಳಗಳಲ್ಲಿ ವ್ಯೂಹದಲ್ಲಿನ ಮೌಲ್ಯಗಳ ವಿನಿಮಯವನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು:

ವಿಧಿವಿಧಾನ ವಿಂಗಡಣೆ ವಿಂಗಡಣೆ

ಪ್ರಾರಂಭಿಸಿ

ವಿಂಗಡಣೆ = ನಿಜವಾದ;

ಸೈಕಲ್ ಮಾಡುವಾಗ ವಿಂಗಡಣೆ = ನಿಜವಾದ;

ವಿಂಗಡಣೆ = ತಪ್ಪು;

Nachalnii_index ನಿಂದ konechii_index-1 ಗೆ ನಾನು ಒಂದು ಲೂಪ್;

Massiv [i]> massiv [i + 1] (ಮೊದಲ ಅಂಶವು ಎರಡಕ್ಕಿಂತಲೂ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ), ಆಗ:

(ನಾವು ಸ್ಥಳಗಳಲ್ಲಿರುವ ಅಂಶಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ);

ವಿಂಗಡಣೆ = ನಿಜವಾದ; (ವಿನಿಮಯ ಮಾಡಿದ ಎಂದು ಸೂಚಿಸಲಾಗಿದೆ).

ಕೊನೆಯಲ್ಲಿ.

ವಿಧಾನದ ಅನಾನುಕೂಲಗಳು

ಮುಖ್ಯ ಅನಾನುಕೂಲವೆಂದರೆ ಪ್ರಕ್ರಿಯೆಯ ಅವಧಿ. ಬಬಲ್ ರೀತಿಯ ಅಲ್ಗಾರಿದಮ್ ಎಷ್ಟು ಸಮಯ ಕೆಲಸ ಮಾಡುತ್ತದೆ ?

ಎಕ್ಸಿಕ್ಯೂಷನ್ ಸಮಯವನ್ನು ರಚನೆಯ ಸಂಖ್ಯೆಗಳ ಸಂಖ್ಯೆಯ ಚೌಕದಿಂದ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲಾಗುತ್ತದೆ - ಅಂತಿಮ ಫಲಿತಾಂಶವು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿರುತ್ತದೆ.

ಕೆಟ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ, ರಚನೆಯು ಹಲವು ಅಂಶಗಳಂತೆ ಹಾದು ಹೋಗುತ್ತದೆ, ಅದರಲ್ಲಿ ಒಂದು ಅಂಶವು ಮೈನಸ್ ಒಂದು ಮೌಲ್ಯ. ಏಕೆಂದರೆ ಇದು ಅಂತಿಮವಾಗಿ ಒಂದು ಅಂಶವನ್ನು ಹೋಲಿಸಲು ಏನೂ ಹೊಂದಿಲ್ಲ, ಮತ್ತು ರಚನೆಯ ಮೂಲಕ ಕೊನೆಯ ಪಾಸ್ ನಿಷ್ಪ್ರಯೋಜಕ ಕ್ರಮವಾಗುತ್ತದೆ.

ಇದರ ಜೊತೆಯಲ್ಲಿ, ಸರಳ ಎಕ್ಸ್ಚೇಂಜ್ಗಳ ಮೂಲಕ ವಿಂಗಡಿಸುವ ವಿಧಾನವನ್ನು ಸಹ ಕರೆಯಲಾಗುತ್ತದೆ, ಸಣ್ಣ ಗಾತ್ರದ ಸರಣಿಗಳಿಗೆ ಮಾತ್ರ ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ. ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ: ಇದರ ಪರಿಣಾಮವಾಗಿ ದೋಷಗಳು ಅಥವಾ ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್ ಆಗಿರುತ್ತದೆ.

ಪ್ರಯೋಜನಗಳು

ಬಬಲ್ ಅನ್ನು ಸಾರ್ಟಿಂಗ್ ಮಾಡುವುದು ತುಂಬಾ ಸುಲಭ. ತಾಂತ್ರಿಕ ವಿಶ್ವವಿದ್ಯಾಲಯಗಳ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ, ಒಂದು ಶ್ರೇಣಿಯ ಅಂಶಗಳ ಆದೇಶವನ್ನು ಅಧ್ಯಯನ ಮಾಡುವಾಗ, ಅದು ಮೊದಲು ಹಾದು ಹೋಗುತ್ತದೆ. ಈ ವಿಧಾನವನ್ನು ಡೆಲ್ಫಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ (ಡಿ (ಡೆಲ್ಫಿ) ಮತ್ತು ಸಿ / ಸಿ ++ (ಸಿ / ಸಿ ಪ್ಲಸ್ ಪ್ಲಸ್)), ಸರಿಯಾದ ಕ್ರಮದಲ್ಲಿ ಮತ್ತು ಪ್ಯಾಸ್ಕಲ್ (ಪ್ಯಾಸ್ಕಲ್) ಗೆ ಮೌಲ್ಯಗಳನ್ನು ಜೋಡಿಸಲು ಅಚ್ಚರಿಯ ಸರಳ ಸರಳ ಕ್ರಮಾವಳಿಗಳಲ್ಲಿ ಸುಲಭವಾಗಿ ಅಳವಡಿಸಬಹುದಾಗಿದೆ .ಒಂದು ಬಬಲ್ನ ವಿಂಗಡಣೆಯು ಆರಂಭಿಕರಿಗಾಗಿ ಸೂಕ್ತವಾಗಿದೆ.

ನ್ಯೂನತೆಗಳು ಕಾರಣ, ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಪಠ್ಯೇತರ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ.

ಬೇರ್ಪಡಿಸುವ ಸ್ಪಷ್ಟ ತತ್ವ

ರಚನೆಯ ಆರಂಭಿಕ ನೋಟ 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

ಪಾಸ್ಕಲ್ನಲ್ಲಿ ಬಬಲ್ನಿಂದ ವಿಂಗಡಿಸುವ ಉದಾಹರಣೆ

ಉದಾಹರಣೆ:

ಕಾನ್ಸ್ kol_mas = 10;

Var massiv: ಪೂರ್ಣಾಂಕದ ಸರಣಿ [1.kol_mas];

ಎ, ಬಿ, ಕೆ: ಪೂರ್ಣಾಂಕ;

ಪ್ರಾರಂಭಿಸಿ

Writeln ('ಇನ್ಪುಟ್', ಕೋಲ್_ಮಾಸ್, 'ಆರ್ಯೆಯ ಅಂಶಗಳು');

A: = 1 ಗೆ kol_mas ಗೆ readln (massiv [a]);

A: = 1 ಗೆ kol_mas-1 ಪ್ರಾರಂಭವಾಗುತ್ತದೆ

B: = a + 1 ಗೆ kol_mas ಪ್ರಾರಂಭವಾಗುತ್ತದೆ

Massiv [a]> massiv [b] ಆಗಿದ್ದರೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ

ಕೆ: = ಸಾಮೂಹಿಕ [ಎ]; ಮ್ಯಾಸಿವ್ [ಎ]: = ಸಾಮೂಹಿಕ [ಬಿ]; ಮ್ಯಾಸಿವ್ [ಬೌ]: = ಕೆ;

ಕೊನೆ;

ಕೊನೆ;

ಕೊನೆ;

Writeln ('ರೀತಿಯ ನಂತರ');

A: = 1 ಗೆ kol_mas do writeln (massiv [a]);

ಕೊನೆ.

ಸಿ (ಸಿ) ನಲ್ಲಿ ಬಬಲ್ನಿಂದ ವಿಂಗಡಿಸುವ ಉದಾಹರಣೆ.

ಉದಾಹರಣೆ:

# ಸೇರಿವೆ

# ಸೇರಿವೆ

ಇಂಟ್ ಮುಖ್ಯ (ಇಂಟ್ ಆರ್ಆರ್ಸಿ, ಚಾರ್ * ಆರ್ಗ್ವಿವ್)]

{

ಇಂಟ್ ಮ್ಯಾಸಿವ್ [8] = {36, 697, 73, 82, 68, 12, 183, 88}, i, ff;

ಫಾರ್ (;;)

Ff = 0;

ಫಾರ್ (ನಾನು = 7; ನಾನು> 0; ನಾನು -) {

(Massiv [i]

ಸ್ವಾಪ್ (Massiv [i], Massiv [i-1]);

Ff ++;

}

}

ವೇಳೆ (ff == 0) ಬ್ರೇಕ್;

}

ಗೆಚ್ (); // ಪರದೆಯ ವಿಳಂಬ

ಹಿಂತಿರುಗಿ 0;

}.