ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿਚ ਤਕਨੀਕ ਲੜੀਬੱਧ: ਲੜੀਬੱਧ "ਬੁਲਬੁਲਾ"

ਬੁਲਬੁਲਾ ਕਰਮ ਨੂੰ ਸਿਰਫ, ਤੇਜ਼ ਢੰਗ ਨੂੰ ਮੰਨਿਆ ਨਾ ਗਿਆ ਹੈ ਇਸ ਦੇ ਇਲਾਵਾ, ਇਸ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਲਈ ਵਿਕਾਸ ਦੇ ਰਾਹ ਦੀ ਸੂਚੀ ਬੰਦ. ਪਰ, ਇਸ ਨੂੰ ਇਸ ਦੇ ਫਾਇਦੇ ਹਨ. ਇਸ ਲਈ, ਬੁਲਬੁਲਾ ਲੜੀਬੱਧ ਦੇ ਢੰਗ - ਸਭ ਹੈ, ਜੋ ਕਿ ਨਾ, ਸਮੱਸਿਆ ਦਾ ਇੱਕ ਕੁਦਰਤੀ ਅਤੇ ਲਾਜ਼ੀਕਲ ਦਾ ਹੱਲ ਹੈ, ਜੇ ਤੁਹਾਨੂੰ ਇੱਕ ਖਾਸ ਕ੍ਰਮ ਵਿੱਚ ਇਕਾਈ ਦਾ ਪ੍ਰਬੰਧ ਕਰਨ ਲਈ ਚਾਹੁੰਦੇ ਹੋ. ਇੱਕ ਆਮ ਵਿਅਕਤੀ ਨੂੰ ਦਸਤੀ, ਉਦਾਹਰਨ ਲਈ, ਇਸ ਨੂੰ ਵਰਤ ਕਰੇਗਾ - ਹੁਣੇ ਹੀ ਸਹਿਜ ਹੈ.

ਕਿੱਥੇ ਅਜਿਹੇ ਇੱਕ ਅਜੀਬ ਨਾਮ ਕੀਤਾ ਸੀ?

ਢੰਗ ਦਾ ਨਾਮ ਆਇਆ ਪਾਣੀ ਵਿੱਚ ਹਵਾ ਬੁਲਬਲੇ ਦੀ ਉਦਾਹਰਣ ਵਰਤ ਕੇ. ਇਹ ਇੱਕ ਅਲੰਕਾਰ ਹੈ. ਉਸੇ ਦੇ ਤੌਰ ਤੇ ਬਹੁਤ ਘੱਟ ਹਵਾ ਬੁਲਬਲੇ ਉਪਰ ਜੀਅ - ਕਿਉਕਿ ਆਪਣੇ ਘਣਤਾ ਦਾ ਇੱਕ ਤਰਲ (ਇਸ ਕੇਸ ਵਿਚ - ਪਾਣੀ) ਵੱਧ ਹੈ, ਅਤੇ ਹਰ ਐਰੇ ਤੱਤ, ਛੋਟੇ ਇਸ ਨੂੰ ਮੁੱਲ, ਸੂਚੀ ਨੰਬਰ ਦੇ ਸਿਖਰ ਨੂੰ ਹੋਰ ਹੌਲੀ ਤਰੀਕਾ ਹੈ.

ਐਲਗੋਰਿਥਮ ਦਾ ਵੇਰਵਾ

ਬੁਲਬੁਲਾ ਕਰਮ ਨੂੰ ਹੇਠ ਕੀਤਾ ਗਿਆ ਹੈ:

• ਪਹਿਲੀ ਪਾਸ: ਐਰੇ ਨੰਬਰ ਦੇ ਤੱਤ ਦੋ ਜੋੜੇ ਦੇ ਕੇ ਲਿਆ ਗਿਆ ਹੈ ਅਤੇ ਇਹ ਵੀ ਸੀ. ਦੋ-ਆਦਮੀ ਨੂੰ ਟੀਮ ਨੂੰ ਪਹਿਲੇ ਮੁੱਲ ਦੇ ਕੁਝ ਤੱਤ ਦੂਜਾ ਵੱਡਾ ਹੈ, ਜੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਮੁਦਰਾ ਸਥਾਨ ਬਣਾ ਦਿੰਦਾ ਹੈ;
• ਸਿੱਟੇ, ਦੇ ਮਹਾਨ ਦਾ ਨੰਬਰ ਮਿਸ ਐਰੇ ਦੇ ਅੰਤ. ਹੋਰ ਸਾਰੇ ਤੱਤ ਰਹਿਣ ਜਦਕਿ ਉਹ ਸਨ, ਇੱਕ ਚੌਥ ਢੰਗ ਵਿੱਚ, ਅਤੇ ਲੜੀਬੱਧ ਹੋਰ ਦੀ ਲੋੜ ਹੈ;
• ਅਤੇ ਇਸ ਲਈ ਇੱਕ ਦੂਜਾ ਪਾਸ ਦੀ ਲੋੜ ਹੈ: ਇਸ ਦੇ ਨਾਲ ਹੀ ਉਦਾਹਰਣ ਦੇ ਕੇ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਪਿਛਲੇ (ਹੀ ਦੱਸਿਆ ਗਿਆ ਹੈ) ਅਤੇ ਤੁਲਨਾ ਦੇ ਇੱਕ ਨੰਬਰ ਦੇ ਹਨ - ਮਨਫ਼ੀ ਇੱਕ;
• ਬੀਤਣ ਨੰਬਰ ਤਿੰਨ ਤੁਲਨਾ, ਦੂਜਾ ਇੱਕ ਘੱਟ ਹੈ, ਅਤੇ ਦੋ, ਪਹਿਲੀ ਵੱਧ 'ਤੇ. ਅਤੇ ਇਸ 'ਤੇ;
• ਸਾਰ ਹਰ ਬੀਤਣ ਹੈ, ਜੋ ਕਿ (ਐਰੇ ਵਿੱਚ ਸਭ ਮੁੱਲ, ਖਾਸ ਨੰਬਰ) ਘਟਾਓ (ਬੀਤਣ ਨੰਬਰ) ਤੁਲਨਾ.

ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੇ ਵੀ ਛੋਟੇ ਐਲਗੋਰਿਥਮ ਦੇ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ:

• ਨੰਬਰ ਦੀ ਲੜੀ ਦੇ ਤੌਰ ਤੇ, ਕਿਸੇ ਵੀ ਦੋ ਨੰਬਰ ਮਿਲਿਆ ਰਹੇ ਹਨ ਤੇ ਲੰਬੇ ਕੀਤੀ ਗਈ ਹੈ ਉਹ ਦੇ ਦੂਜੇ ਪਹਿਲੇ ਵੱਧ ਹੋਣਾ ਹੀ ਹੈ;
• ਗਲਤ ਐਰੇ ਸਾਫਟਵੇਅਰ ਿੀਨੀ ਦੇ ਇਕ-ਦੂਜੇ ਨੂੰ ਤੱਤ ਦੇ ਸਬੰਧ ਵਿੱਚ ਸਥਿਤੀ.

ਐਲਗੋਰਿਥਮ ਦੱਸਿਆ ਗਿਆ ਤੇ ਆਧਾਰਿਤ Pseudocode

ਸਧਾਰਨ ਨੂੰ ਲਾਗੂ ਬਾਹਰ ਹੀ ਹੇਠ ਦਿੱਤਾ ਹੈ:

Sortirovka_Puzirkom ਵਿਧੀ;

ਸ਼ੁਰੂ

nachalnii_index konechii_index ਤੱਕ ਜੰਮੂ ਲਈ ਚੱਕਰ;

konechii_index-1 nachalnii_index ਮੈਨੂੰ ਲਈ ਚੱਕਰ;

ਜੇ massiv [i]> massiv [i + 1] (ਪਹਿਲੇ ਇੱਕ ਦੂਜੀ ਵੱਧ ਤੱਤ), ਫਿਰ:

(ਤਬਦੀਲੀ ਮੁੱਲ ਰੱਖਦਾ ਹੈ);

ਅੰਤ

ਇਹ ਸੱਚ ਹੈ, ਇਸ ਸਾਦਗੀ ਸਿਰਫ ਸਥਿਤੀ ਨੂੰ aggravates: ਸੌਖਾ ਐਲਗੋਰਿਥਮ ਹੈ, ਹੋਰ ਇਸ ਨੂੰ ਸਭ ਫਲਾਅ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ. ਵਾਰ ਦੇ ਨਿਵੇਸ਼ ਦਾ ਅਨੁਪਾਤ (: ਆਮ ਲਈ ਵਾਰ ਦੀ ਮਾਤਰਾ ਨੂੰ ਛੋਟਾ ਜਾਪਦਾ ਹੈ, ਪਰ ਅਸਲ ਵਿੱਚ ਇੱਕ ਪਰੋਗਰਾਮਰ ਹਰ ਦੂਜਾ ਜ ਵੀ ਮਿਲੀਸਕਿੰਟ ਗਿਣਤੀ ਇੱਥੇ ਰੀਲੇਟੀਵਿਟੀ ਵਿੱਚ ਆ) ਵੀ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਐਰੇ ਲਈ ਬਹੁਤ ਮਹਾਨ ਹੈ.

ਇਹ ਬਿਹਤਰ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਸੀ. ਉਦਾਹਰਨ ਲਈ, ਖਾਤੇ ਵਿੱਚ ਐਰੇ ਸਥਾਨ ਵਿੱਚ ਮੁੱਲ ਦੀ ਮੁਦਰਾ ਨੂੰ ਲੈ ਕੇ:

Sortirovka_Puzirkom ਵਿਧੀ;

ਸ਼ੁਰੂ

sortirovka ਸੱਚ ਹੈ =;

ਚੱਕਰ sortirovka ਸੱਚ ਹੈ = ਜਦ ਤਕ;

sortirovka = ਝੂਠੇ,

konechii_index-1 nachalnii_index ਮੈਨੂੰ ਲਈ ਚੱਕਰ;

ਜੇ massiv [i]> massiv [i + 1] (ਪਹਿਲੇ ਇੱਕ ਦੂਜੀ ਵੱਧ ਤੱਤ), ਫਿਰ:

(ਤੱਤ ਸਥਾਨ ਨੂੰ ਬਦਲਣ);

sortirovka ਸੱਚ ਹੈ =; (ਦੀ ਪਛਾਣ ਹੈ, ਜੋ ਕਿ ਮੁਦਰਾ ਕੀਤਾ ਗਿਆ ਹੈ).

ਅੰਤ.

ਇਸਤੇਮਾਲ

ਮੁੱਖ ਨੁਕਸਾਨ - ਕਾਰਜ ਦਾ ਅੰਤਰਾਲ. ਬਹੁਤ ਕੁਝ ਵਾਰ ਕੀਤਾ ਗਿਆ ਹੈ ਐਲਗੋਰਿਥਮ ਲੜੀਬੱਧ ਬੁਲਬੁਲਾ?

ਲੀਡ ਵਾਰ ਵਰਗ ਨੰਬਰ ਦੀ ਗਿਣਤੀ ਦਾ ਹਿਸਾਬ ਲਗਾਇਆ ਗਿਆ ਹੈ, ਐਰੇ ਵਿੱਚ - ਇਸ ਦੇ ਅੰਤ ਦਾ ਨਤੀਜਾ ਅਨੁਪਾਤ ਹੈ.

ਐਰੇ ਨੂੰ ਕਈ ਵਾਰ ਦੇ ਤੌਰ ਤੇ ਪਾਸ ਕੀਤਾ ਹੈ ਸਭ ਕੇਸ ਹੈ, ਜੇ ਇਸ ਨੂੰ ਇੱਕ ਮੁੱਲ ਸਿਫਰ ਤੱਤ ਹੈ ਦੇ ਰੂਪ ਵਿੱਚ. ਇਹ ਵਾਪਰਦਾ ਹੈ ਕੇਵਲ ਇੱਕ ਹੀ ਤੱਤ ਹੁੰਦਾ ਹੈ ਅੰਤ ਵਿਚ, ਕਿਉਕਿ, ਜੋ ਕਿ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਕੁਝ ਵੀ ਹੈ, ਅਤੇ ਐਰੇ ਦੁਆਰਾ ਪਿਛਲੇ ਪਾਸ ਬੇਕਾਰ ਕਾਰਵਾਈ ਦੀ ਹੈ.

ਇਸ ਦੇ ਨਾਲ, ਇੱਕ ਸਧਾਰਨ ਮੁਦਰਾ ਲੜੀਬੱਧ, ਦੇ ਰੂਪ ਵਿੱਚ ਇਸ ਨੂੰ, ਨੂੰ ਕਿਹਾ ਗਿਆ ਹੈ ਕਿ ਸਿਰਫ ਛੋਟੇ ਆਕਾਰ ਦੇ ਐਰੇ ਲਈ ਅਸਰਦਾਰ ਢੰਗ ਹੈ. ਕਾਰਜ ਦੀ ਮਦਦ ਨਾਲ ਡਾਟਾ ਦੀ ਵੱਡੀ ਮਾਤਰਾ ਕੰਮ ਨਹੀ ਕਰੇਗਾ: ਇਸ ਦਾ ਨਤੀਜਾ ਕਿਸੇ ਇੱਕ ਗਲਤੀ ਜ ਦੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਅਸਫਲਤਾ ਹੋ ਜਾਵੇਗਾ.

ਦਾ ਮਾਣ

ਬੁਲਬੁਲਾ ਕਰਮ ਨੂੰ ਸਮਝਣ ਲਈ ਬਹੁਤ ਹੀ ਆਸਾਨ ਹੈ. ਇਸ ਦੇ ਐਰੇ ਦੇ ਕ੍ਰਮ ਤੱਤ ਦੀ ਸਟੱਡੀ ਕਰਨ ਵਿਚ ਤਕਨੀਕੀ ਯੂਨੀਵਰਸਿਟੀ ਦੇ ਪਾਠਕ੍ਰਮ ਨੂੰ ਪਹਿਲੇ ਸਥਾਨ ਵਿੱਚ ਪਾਸ. ਢੰਗ ਦੀ ਦੋਨੋ ਡੈਲਫੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ (L (ਡੈਲਫੀ), ਅਤੇ C / C ++ (C / C ਪਲੱਸ ਪਲੱਸ), ਨੂੰ ਸਹੀ ਕ੍ਰਮ ਵਿੱਚ ਹਨ ਅਤੇ 'ਤੇ ਸਥਿਤੀ ਨੂੰ ਐਲਗੋਰਿਥਮ ਦੀ ਇੱਕ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਮੁੱਲ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਆਸਾਨ ਹੈ, ਪਾਸਕਲ (ਪਾਸਕਲ). ਬੱਬਲ ਕਿਸਮ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਨ ਲਈ ਆਦਰਸ਼ ਹੈ.

ਐਲਗੋਰਿਥਮ ਦੀ ਨੁਕਸਾਨ ਦੇ ਕਾਰਨ ਪਾਠਕ੍ਰਮ ਦੇ ਮਕਸਦ ਵਿੱਚ ਵਰਤਿਆ ਨਾ ਗਿਆ ਹੈ.

ਵਿਜ਼ੁਅਲ ਲੜੀਬੱਧ ਅਸੂਲ

ਐਰੇ 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 ( 'ਇੰਪੁੱਟ', kol_mas, 'ਅਰੇ ਦੇ ਤੱਤ');

ਨੂੰ ਇੱਕ ਲਈ: = 1 kol_mas ਨੂੰ readln ਕੀ (massiv [a ]);

ਨੂੰ ਇੱਕ ਲਈ: = 1 kol_mas-1 ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਕੀ

ਅ ਲਈ: = a + 1 kol_mas ਕਰਨ ਲਈ ਸ਼ੁਰੂ ਹੋ

ਜੇ massiv [A]> massiv [ b] ਫਿਰ ਸ਼ੁਰੂ

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

ਨੂੰ ਖਤਮ;

ਨੂੰ ਖਤਮ;

ਨੂੰ ਖਤਮ;

writeln ( 'ਕਰਮ ਨੂੰ ਬਾਅਦ');

ਨੂੰ ਇੱਕ ਲਈ: = 1 kol_mas ਨੂੰ writeln ਕੀ (massiv [a ]);

ਅੰਤ.

ਮਿਸਾਲ ਬੁਲਬੁਲਾ C ਭਾਸ਼ਾ ਵਿਚ ਲੜੀਬੱਧ (C)

ਉਦਾਹਰਨ:

#include

#include

ਇੰਟ ਮੁੱਖ (ਇੰਟ argc, char * ਲਾਗਫਾਇਲ [])

{

ਇੰਟ massiv [8] = {36, 697, 73, 82, 68, 12, 183, 88}, ਮੈਨੂੰ, FF;

ਲਈ (;;) {

FF = 0;

ਲਈ (i = 7; i> 0; i -) {

ਜੇ (massiv [i] [i- 1]) {

ਸਵੈਪ (massiv [i], massiv [i- 1]);

FF ++;

}

}

ਜੇ (FF == 0) ਨੂੰ ਤੋੜ;

}

getch (); // ਡਿਸਪਲੇਅ ਦੇਰੀ

0 ਵਾਪਸ ਜਾਣ;

}.