[Powered by Google Translate] ನೀವು ಬಹುಶಃ ಜನರು ವೇಗದ ಅಥವಾ ದಕ್ಷ ಅಲ್ಗಾರಿದಮ್ ಬಗ್ಗೆ ಕೇಳಿರುವ ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುವುದಕ್ಕಾಗಿ, ಆದರೆ ವೇಗದ ಅಥವಾ ದಕ್ಷ ಎಂದು ಒಂದು ಅಲ್ಗಾರಿದಮ್ ಫಾರ್ ನಿಖರವಾಗಿ ಏನು? ಅಲ್ಲದೆ, ಇದು ನೈಜ ಸಮಯದಲ್ಲಿ ಒಂದು ಮಾಪನದ ಬಗ್ಗೆ ದೊರೆಯದಿದ್ದಲ್ಲಿ ಸೆಕೆಂಡ್ಗಳು ಅಥವಾ ನಿಮಿಷಗಳು ನಂತಹ. ಈ ಕಾರಣ ಕಂಪ್ಯೂಟರ್ ಯಂತ್ರಾಂಶ ಮತ್ತು ಸಾಫ್ಟ್ವೇರ್ ತೀವ್ರವಾಗಿ ಬದಲಾಗುತ್ತದೆ. ನನ್ನ ಪ್ರೋಗ್ರಾಂ, ನಿಮ್ಮ ನಿಧಾನವಾಗಿ ರನ್ ಆಗಬಹುದು ನಾನು ಹಳೆಯ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ಇದು ಚಾಲನೆಯಲ್ಲಿರುವ ನಾನು ಏಕೆಂದರೆ ಅಥವಾ ನಾನು ಆನ್ಲೈನ್ ವೀಡಿಯೊ ಆಟದಲ್ಲಿ ಎಂದು ಸಂಭವಿಸಿ ಏಕೆಂದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ, ಇದು ನನ್ನ ಮೆಮೊರಿ hogging ಇದೆ ಅಥವಾ ನಾನು ವಿವಿಧ ತಂತ್ರಾಂಶ ಮೂಲಕ ನನ್ನ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಇರಬಹುದು ಇದು ಕಡಿಮೆ ಮಟ್ಟದ ವಿಭಿನ್ನವಾಗಿ ಯಂತ್ರ ಸಂವಹನ. ಇದು ಸೇಬು ಮತ್ತು ಕಿತ್ತಳೆ ಹೋಲಿಸುವ ಅನಿಸುತ್ತದೆ. ನನ್ನ ನಿಧಾನವಾಗಿ ಕಂಪ್ಯೂಟರ್ ಮುಂದೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಕೇವಲ ನಿಮ್ಮ ಉತ್ತರವನ್ನು ಹಿಂದಕ್ಕೆ ನೀಡಲು ಹೆಚ್ಚು ನೀವು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಅಲ್ಗಾರಿದಮ್ ಹೊಂದಿದೆ ಎಂದಲ್ಲ. 

ಆದ್ದರಿಂದ, ನಾವು ನೇರವಾಗಿ ಕಾರ್ಯಕ್ರಮಗಳ ರನ್ಟೈಮ್ಗಳನ್ನು ಹೋಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಸೆಕೆಂಡುಗಳು ಅಥವಾ ನಿಮಿಷಗಳಲ್ಲಿ, ಹೇಗೆ ನಾವು 2 ವಿವಿಧ ಕ್ರಮಾವಳಿಗಳು ಹೋಲಿಸಿ ನೋಡಬಹುದು ಯಾವುದೇ ಹಾರ್ಡ್ವೇರ್ ಅಥವಾ ಸಾಫ್ಟ್ವೇರ್ ಪರಿಸರದ? ಕ್ರಮಾವಳಿಯ ದಕ್ಷತೆ ಅಳೆಯಲು ಒಂದು ಏಕರೂಪದ ರೀತಿಯಲ್ಲಿ ರಚಿಸಲು, ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನಿಗಳು ಹಾಗೂ ಗಣಿತಜ್ಞರು ರೂಪಿಸಿದರು ಎಂದು ಒಂದು ಕಾರ್ಯಕ್ರಮದ ಅಸಂಪಾತ ಸಂಕೀರ್ಣತೆ ಅಳೆಯುವ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ಒಂದು ಸಂಕೇತ 'ಬಿಗ್ Ohnotation' ಎಂಬ ಈ ಸೂಚಿಸಲು. ಔಪಚಾರಿಕ ವ್ಯಾಖ್ಯಾನವನ್ನು ಒಂದು ಫಂಕ್ಷನ್ f (x) ಗ್ರಾಂ ಕ್ರಮವನ್ನು (X) ಚಲಿಸುತ್ತದೆ ಕೆಲವು (X) ಮೌಲ್ಯವನ್ನು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ವೇಳೆ, X ₀ ಮತ್ತು ಕೆಲವು ಸ್ಥಿರ, ಸಿ, ಯಾವ f (x) ಕಡಿಮೆ ಅಥವಾ ಸಮ ಆ ನಿರಂತರ ಬಾರಿ g (x) X ₀ ಹೆಚ್ಚಿನ ಎಲ್ಲಾ x ಗಾಗಿ. 

ಆದರೆ ಔಪಚಾರಿಕ ವ್ಯಾಖ್ಯಾನವನ್ನು ಕೂಡಿದೆ ನಿಮಗಿರುವುದು ಇಲ್ಲ. ಈ ವಾಸ್ತವವಾಗಿ ಸೈದ್ಧಾಂತಿಕ ಪದಗಳನ್ನು ಕಡಿಮೆ ಅರ್ಥ ಏನು? ಅಲ್ಲದೆ, ಇದು ಮೂಲತಃ ವಿಶ್ಲೇಷಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ ಒಂದು ಪ್ರೋಗ್ರಾಂ ನ ರನ್ಟೈಮ್ asymptotically ಬೆಳೆಯುತ್ತದೆ ಎಷ್ಟು ವೇಗವಾಗಿ. ನಿಮ್ಮ ಒಳಹರಿವಿನ ಗಾತ್ರ ಅನಂತ ಕಡೆಗೆ ಹೆಚ್ಚಿಸುತ್ತದೆ ಎಂದು, ಇದು ಸೇ, ನೀವು ಗಾತ್ರ 10 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೋಲಿಸಿದರೆ ಗಾತ್ರದಲ್ಲಿ 1000 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ವಿಂಗಡಿಸುವ ಮಾಡುತ್ತಿದ್ದೇವೆ. ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ರನ್ಟೈಮ್ ಹೇಗೆ ಬೆಳೆಯುತ್ತವೆ ಮಾಡುವುದಿಲ್ಲ? ಉದಾಹರಣೆಗೆ, ಪಾತ್ರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವ ಕಲ್ಪನೆ ಒಂದು ಸಾಲಿನಲ್ಲಿ ಸರಳ ರೀತಿಯಲ್ಲಿ  ಇಡೀ ಅಕ್ಷರ ಮೂಲಕ ಕಾಲ್ನಡಿಗೆಯಲ್ಲೇ ಪತ್ರ ಅದಕ್ಕೆ ಅಕ್ಷರದ ಮತ್ತು ಪ್ರತಿ ಪಾತ್ರಕ್ಕೆ ಪ್ರತಿ 1 ಸೇರಿಸುವ. ಈ ಕ್ರಮಾವಳಿಯ ರೇಖೀಯ ಸಮಯದಲ್ಲಿ ರನ್ ಹೇಳಲಾಗುತ್ತದೆ ಪಾತ್ರಗಳು ಸಂಖ್ಯೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಸಾಲಿನಲ್ಲಿ 'ಎನ್'. ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ಇದು ಒ (N) ರಲ್ಲಿ ಚಲಾಯಿಸುತ್ತದೆ. ಏಕೆ ಈ? ಅಲ್ಲದೆ, ಈ ವಿಧಾನ ಬಳಸಿ, ಸಮಯ ಅಗತ್ಯವಿದೆ ಇಡೀ ಸ್ಟ್ರಿಂಗ್ ಹಾದುಹೋಗಬೇಕಾದರೆ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯು ಅನುಪಾತದಲ್ಲಿರುತ್ತದೆ. 20 ಅಕ್ಷರ ಸ್ಟ್ರಿಂಗ್ ಪಾತ್ರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎರಡರಷ್ಟು ಉದ್ದದ ನಾಯಕನನ್ನು ಇದೆ 10 ಅಕ್ಷರ ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳನ್ನು ಎಣಿಸಲು, ನೀವು ಎಲ್ಲಾ ಪಾತ್ರಗಳು ನೋಡಲು ಏಕೆಂದರೆ ಮತ್ತು ಪ್ರತಿ ಪಾತ್ರದ ನೋಡಲು ಅಷ್ಟೇ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನೀವು ಪಾತ್ರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹೆಚ್ಚಿಸುವ, ಮಾಹಿತಿ ರನ್ಟೈಮ್ ಇನ್ಪುಟ್ ಉದ್ದ ರೇಖೀಯವಾಗಿ ಹೆಚ್ಚಾಗುತ್ತದೆ. 

ಆ ರೇಖೀಯ ಕಾಲದ ನಿರ್ಧರಿಸಿದರೆ ಈಗ, ಕಲ್ಪನೆ ಒ (N), ಕೇವಲ ಸಾಕಷ್ಟು ವೇಗವಾಗಿ ನೀವು ಅಲ್ಲ? ಬಹುಶಃ ನೀವು ಭಾರೀ ತಂತಿಗಳ ಸಂಗ್ರಹಿಸಲು ನೀವು ಮತ್ತು ನೀವು ತೆಗೆದುಕೊಳ್ಳುವ ಹೆಚ್ಚುವರಿ ಸಮಯ ಹೊಂದಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಒಂದು ಮೂಲಕ ಒಂದು ಎಣಿಸುವ ಅವರ ಪಾತ್ರಗಳು ಎಲ್ಲಾ ಹಾದುಹೋಗಬೇಕಾದರೆ. ಆದ್ದರಿಂದ, ನೀವು ಬೇರೆ ಪ್ರಯತ್ನಿಸಲು ನಿರ್ಧರಿಸಿ. ನೀವು ಈಗಾಗಲೇ ಪಾತ್ರಗಳ ಸಂಖ್ಯೆ ಸಂಗ್ರಹಿಸಲು ಏನಾಗಬಹುದು ವೇಳೆ ಸಾಲಿನಲ್ಲಿ, ', ಲೆನ್' ಎಂಬ ವೇರಿಯಬಲ್, ಸೇ ಆರಂಭದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ನಲ್ಲಿ, ನೀವು ಸಹ ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಬಹಳ ಮೊದಲ ಅಕ್ಷರ ಸಂಗ್ರಹವಾಗಿರುವ ಮೊದಲು? ನಂತರ, ಎಲ್ಲಾ ನೀವು, ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ ಕಂಡುಹಿಡಿಯಲು ಈಗ ಮಾಡಬೇಕು ಬಯಸುವ ವೇರಿಯಬಲ್ ಮೌಲ್ಯವನ್ನು ಏನು ಪರಿಶೀಲಿಸಿ ಇದೆ. ನೀವು ಎಲ್ಲಾ ಸಮಯದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಸ್ವತಃ ನೋಡಲು ಅಗತ್ಯವಿಲ್ಲ ಮತ್ತು ಲೆನ್ ಒಂದು ವೇರಿಯೇಬಲ್ ಮೌಲ್ಯವನ್ನು ಪ್ರವೇಶಿಸುವ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಒಂದು asymptotically ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಯ ಅಥವಾ ಓ (1). ಏಕೆ ಈ? ಅಲ್ಲದೆ, ಅಸಂಪಾತ ಸಂಕೀರ್ಣತೆಯನ್ನು ಅರ್ಥ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ. ಹೇಗೆ ಗಾತ್ರವು ರನ್ಟೈಮ್ ಬದಲಾಗಬಹುದು ನಿಮ್ಮ ಒಳಹರಿವು ಬೆಳೆಯುತ್ತದೆ? 

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

ಸಹಜವಾಗಿ, ಒಂದು ನ್ಯೂನತೆ ಇತ್ತು. ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿ ಸ್ಪೇಸ್ ಖರ್ಚು ವೇರಿಯಬಲ್ ಸಂಗ್ರಹಿಸುವ ಮತ್ತು ನೀವು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಹೆಚ್ಚುವರಿ ಸಮಯ ವೇರಿಯಬಲ್ ನಿಜವಾದ ಸಂಗ್ರಹ ಮಾಡಲು, ಆದರೆ ಪಾಯಿಂಟ್ ಇನ್ನೂ ನಿಂತಿದೆ, ನಿಮ್ಮ ವಾಕ್ಯವನ್ನು ಹೇಗೆ ದೀರ್ಘ ಪತ್ತೆ ಎಲ್ಲ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ ಅವಲಂಬಿಸಿಲ್ಲ. ಆದ್ದರಿಂದ, ಇದು ಒ (1) ಅಥವಾ ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಸಾಗುತ್ತದೆ. ಈ ಖಂಡಿತವಾಗಿಯೂ ಅರ್ಥ ಹೊಂದಿಲ್ಲ ನಿಮ್ಮ ಕೋಡ್, 1 ಹಂತದಲ್ಲಿ ಚಾಲನೆ ಆದರೆ ಯಾವುದೇ ಎಷ್ಟು ಹಂತಗಳನ್ನು ಅದು, ಇದು ಒಳಹರಿವಿನ ಗಾತ್ರದೊಂದಿಗೆ ಬದಲಾಗದ, ಈಗಲೂ ನಾವು ಒ (1) ಮಾಹಿತಿ ಪ್ರತಿನಿಧಿಸುವ asymptotically ಸ್ಥಿರ ಇಲ್ಲಿದೆ. 

ನೀವು ಬಹುಶಃ ಊಹೆ ಮಾಡಬಹುದು ಎಂದು, ಜೊತೆಗೆ ಕ್ರಮಾವಳಿಗಳು ಅಳೆಯಲು ವಿವಿಧ ದೊಡ್ಡ ಒ ರನ್ಟೈಮ್ಗಳನ್ನು ಇವೆ. ಒ (N) ² ಕ್ರಮಾವಳಿಗಳು O (N) ಕ್ರಮಾವಳಿಗಳಿಗಿಂತ asymptotically ನಿಧಾನವಾಗಿರುತ್ತವೆ. ಘಟಕಗಳ ಸಂಖ್ಯೆ (n) ಬೆಳೆಯುತ್ತದೆ ಎಂದು, ಇದು ಅಂತಿಮವಾಗಿ O (N) ² ಕ್ರಮಾವಳಿಗಳು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಒ (N) ಕ್ರಮಾವಳಿಗಳು ಚಲಾಯಿಸಲು ಹೆಚ್ಚು. ಈ ಒ (N) ಕ್ರಮಾವಳಿಗಳು ಯಾವಾಗಲೂ ವೇಗವಾಗಿ ರನ್ ಅರ್ಥವಲ್ಲ ಒ (N) ² ಕ್ರಮಾವಳಿಗಳಿಗಿಂತ, ಒಂದೇ ಪರಿಸರದಲ್ಲಿ, ಅದೇ ಯಂತ್ರಾಂಶಕ್ಕೆ. ಬಹುಶಃ ಸಣ್ಣ ಇನ್ಪುಟ್ ಗಾತ್ರಕ್ಕಾಗಿ  ಒ (N) ² ಅಲ್ಗಾರಿದಮ್ ವಾಸ್ತವವಾಗಿ, ವೇಗವಾಗಿ ಕೆಲಸ ಆದರೆ, ಅಂತಿಮವಾಗಿ, ಇನ್ಪುಟ್ ಗಾತ್ರ ಹೆಚ್ಚಿಸುತ್ತದೆ ಅನಂತ ಕಡೆಗೆ, O (N) ² ಅಲ್ಗಾರಿದಮ್ ನ ರನ್ಟೈಮ್ ಅಂತಿಮವಾಗಿ O (N) ಕ್ರಮಾವಳಿಯ ರನ್ಟೈಮ್ ಮೀರಿಸಬಹುದು ಕಾಣಿಸುತ್ತದೆ. ಯಾವುದಾದರೂ ವರ್ಗ ಗಣಿತ ಕಾರ್ಯದ ರೀತಿಯಲ್ಲಿ  ಅಂತಿಮವಾಗಿ ಯಾವುದೇ ರೇಖೀಯ ಕಾರ್ಯ ಹಿಂದಿಕ್ಕಿ ಕಾಣಿಸುತ್ತದೆ, ಎಷ್ಟು ತಲೆ ರೇಖೀಯ ಕಾರ್ಯವನ್ನು ಆರಂಭಿಸಲು ಯಾವುದೇ ಜೊತೆಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ನೀವು ದತ್ತಾಂಶದ ದೊಡ್ಡ ಪ್ರಮಾಣಗಳ ಜೊತೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದಾರೆ ಓ ಚಲಾಯಿಸಲು ಕ್ರಮಾವಳಿಗಳನ್ನು (N) ² ಸಮಯ ನಿಜವಾಗಿಯೂ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಿಧಾನವಾಗುತ್ತಿದೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮಾಡಬಹುದು ಆದರೆ ಸಣ್ಣ ಇನ್ಪುಟ್ ಗಾತ್ರಕ್ಕಾಗಿ ನೀವು ಬಹುಶಃ ಗಮನಕ್ಕೆ ಸಹ ಆಗುವುದಿಲ್ಲ. 

ಮತ್ತೊಂದು ಅಸಂಪಾತ ಸಂಕೀರ್ಣತೆ, ಆಗಿದೆ ಲಾಗರಿದಮ್ ಸಮಯ, ಒ (ಲಾಗ್ N). ಶೀಘ್ರವಾಗಿ ಈ ಹಾದು ಒಂದು ಕ್ರಮಾವಳಿಯ ಒಂದು ಉದಾಹರಣೆ , ಶಾಸ್ತ್ರೀಯ ಬೈನರಿ ಸರ್ಚ್ ಕ್ರಮಾವಳಿ ಅಂಶಗಳ ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾದ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಅಂಶ ಹುಡುಕುವ. 

ನೀವು ಬೈನರಿ ಸರ್ಚ್ ಏನು ಗೊತ್ತಿಲ್ಲ ವೇಳೆ, ನಾನು ತಕ್ಷಣ ನೀವು ಅದನ್ನು ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ. ಲೆಟ್ಸ್ ನೀವು ಸಂಖ್ಯೆ 3 ಹುಡುಕುತ್ತಿರುವ ಹೇಳುತ್ತಾರೆ ಪೂರ್ಣಾಂಕಗಳ ಈ ಶ್ರೇಣಿಯಲ್ಲಿನ. ಇದು ರಚನೆಯ ಮಧ್ಯಮ ಅಂಶ ನೋಡುತ್ತದೆ ಮತ್ತು "ನಾನು ಹೆಚ್ಚು ಬಯಸುವ ಅಂಶ, ಸಮಾನ ಅಥವಾ ಈ ಕಡಿಮೆ?", ಕೇಳುತ್ತದೆ ಇದು ನಂತರ ಉತ್ತಮ, ಸಮಾನ ಸರಿ. ನೀವು ಅಂಶ ಕಂಡು, ಮತ್ತು ನೀವು ಮುಗಿಸಿದ್ದೀರಿ. ಇದು ಹೆಚ್ಚು ಇದ್ದರೆ, ಆಗ ನೀವು ಅಂಶ ತಿಳಿದಿದೆ , ರಚನೆಯ ಬಲಭಾಗದ ಎಂದು ಹೊಂದಿದೆ ಮತ್ತು ನೀವು ಮಾತ್ರ, ಭವಿಷ್ಯದಲ್ಲಿ ಆ ನೋಡಬಹುದು ಇದು ಸಣ್ಣ ಇದ್ದರೆ ಮತ್ತು, ನಂತರ ನೀವು ಎಡಗಡೆಯಲ್ಲಿ ಎಂದು ಹೊಂದಿದೆ ತಿಳಿದಿದೆ. ಈ ಪ್ರಕ್ರಿಯೆಯ ನಂತರ ಸಣ್ಣ ಗಾತ್ರದ ಸಹಿತ ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ ಸರಿಯಾದ ಅಂಶ ಕಂಡುಬರುತ್ತದೆ ರವರೆಗೆ. 

ಈ ಶಕ್ತಿಶಾಲಿ ಅಲ್ಗಾರಿದಮ್ ಪ್ರತಿ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ ಅರ್ಧ ರಚನೆಯ ಗಾತ್ರ ಕತ್ತರಿಸಿ. ಆದ್ದರಿಂದ, ಗಾತ್ರ 8 ಒಂದು ವಿಂಗಡಿಸಲಾದ ಶ್ರೇಣಿಯಲ್ಲಿನ ಒಂದು ಅಂಶ ಹುಡುಕಲು, ಹೆಚ್ಚೆಂದರೆ (₂ 8 ಲಾಗಿನ್) ಈ ಕಾರ್ಯಾಚರಣೆಗಳ ಅಥವಾ 3, ಮಧ್ಯಮ ಅಂಶ ಪರೀಕ್ಷಿಸುವುದು, ನಂತರ ಅರ್ಧ ರಚನೆಯ ಕತ್ತರಿಸುವುದು, ಅಗತ್ಯವಿದೆ ಗಾತ್ರ 16 ಒಂದು ಶ್ರೇಣಿಯನ್ನು, (₂ 16 ಲಾಗ್) ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಆದರೆ ಅಥವಾ 4 ಕಾರ್ಯಾಚರಣೆಗಳು. ಕೇವಲ ಒಂದು ದುಪ್ಪಟ್ಟು ಗಾತ್ರದ ಶ್ರೇಣಿಗೆ 1 ಹೆಚ್ಚು ಕಾರ್ಯಾಚರಣೆಯ. ರಚನೆಯ ಗಾತ್ರ ದ್ವಿಗುಣಗೊಳಿಸುವ ಈ ಕೋಡ್ ಕೇವಲ 1 ಚಂಕ್ ಅದಕ್ಕೆ ರನ್ಟೈಮ್ ಹೆಚ್ಚಿಸುತ್ತದೆ. ಮತ್ತೆ, ನಂತರ ವಿಭಜಿಸುವ ಪಟ್ಟಿಯ ಮಧ್ಯಮ ಅಂಶ ಪರೀಕ್ಷಿಸುವುದು. ಆದ್ದರಿಂದ, ಇದು, ಲಾಗರಿದಮ್ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಹೇಳಲಾಗುತ್ತದೆ ಒ (ಲಾಗ್ N). ಆದರೆ, ನೀವು ಹೇಳುವ, ನಿರೀಕ್ಷಿಸಿ ಪಟ್ಟಿಯಲ್ಲಿ ನೀವು ಹುಡುಕುತ್ತಿರುವ ಅಂಶ ಅಲ್ಲಿ ಈ ಅವಲಂಬಿಸಿಲ್ಲ? ಹೀಗಾದರೆ ನೀವು ನೋಡಲು ಮೊದಲ ಅಂಶ ಬಲ ಎಂದು ಏನಾಗುತ್ತದೆ? ನಂತರ, ಕೇವಲ, 1 ಕಾರ್ಯಾಚರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಪಟ್ಟಿ ಎಷ್ಟು ದೊಡ್ಡ ಯಾವುದೇ. 

ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನಿಗಳು ಹೆಚ್ಚು ಪದಗಳನ್ನು ಏಕೆ ಹಾಗೆಯೇ, ಆ ಸ್ ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಪ್ರತಿಬಿಂಬಿಸುವ ಅಸಂಪಾತ ಸಂಕೀರ್ಣತೆಯಿಂದಾಗಿ ಮತ್ತು ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಕ್ರಮಾವಳಿಯ ಪ್ರದರ್ಶನಗಳು. ಹೆಚ್ಚು ಸರಿಯಾಗಿ, ಮೇಲಿನ ಮತ್ತು ಕೆಳಗಿನ ಪರಿಮಿತಿ ರನ್ಟೈಮ್ ಮೇಲೆ. ಬೈನರಿ ಸರ್ಚ್ ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಮ್ಮ ಅಂಶ ಬಲ ಅಲ್ಲಿ ಮಧ್ಯದಲ್ಲಿ, ಮತ್ತು ನೀವು, ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಅದು ಸಿಗುತ್ತದೆ ಸರಣಿ ಉಳಿದ ಹೇಗೆ ದೊಡ್ಡದಾಗಿದೆ ಯಾವುದೇ. ಈ ಬಳಸುವ ಚಿಹ್ನೆ Ω ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ, ಈ ಅಲ್ಗಾರಿದಮ್ Ω (1) ಚಲಾಯಿಸಲು ಹೇಳಲಾಗುತ್ತದೆ. ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ತ್ವರಿತವಾಗಿ ಅಂಶ ಕಂಡುಕೊಳ್ಳುತ್ತದೆ ಅರೇ ಎಷ್ಟು ದೊಡ್ಡ ಯಾವುದೇ, ಆದರೆ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು (ಲಾಗ್ N) ಸ್ಪ್ಲಿಟ್ ಚೆಕ್ ಮಾಡಲು ಹೊಂದಿದೆ ರಚನೆಯ ಬಲ ಅಂಶ ಪಡೆಯುವುದು. ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಮೇಲಿನ ಗಡಿ ನೀವು ಈಗಾಗಲೇ ತಿಳಿದಿರುವ ದೊಡ್ಡ "ಓ" ಸೂಚಿಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಇದು ಒ (ಲಾಗ್ N), ಆದರೆ Ω (1) ದ. 

ರೇಖೀಯ ಹುಡುಕಾಟ ತದ್ವಿರುದ್ಧವಾಗಿ, ನೀವು ರಚನೆಯ ಪ್ರತಿ ಅಂಶ ಸಂಚರಿಸಲು ಇದರಲ್ಲಿ ನೀವು ಒಂದು ಹುಡುಕಲು, ಅತ್ಯುತ್ತಮ Ω (1) ನಲ್ಲಿ ಹೊಂದಿದೆ. ಮತ್ತೆ, ಮೊದಲ ಅಂಶ ನೀವು ಬಯಸುವ. ಆದ್ದರಿಂದ, ಅದು ರಚನೆಯ ಎಷ್ಟು ದೊಡ್ಡ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ. ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ರಚನೆಯ ಕೊನೆಯ ಅಂಶವಾಗಿದೆ. ಆದ್ದರಿಂದ, ನೀವು ಖರೀದಿ ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಲ್ಲಾ N ಅಂಶಗಳ ಮೂಲಕ ನಡೆಯಬೇಕು ನೀವು 3 ಹುಡುಕುತ್ತಿರುವ ವೇಳೆ ಇಷ್ಟ. ಆದ್ದರಿಂದ, ಇದು ಒ (N) ಸಮಯದಲ್ಲಿ ರನ್ ಇದು ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಅನುಪಾತದಲ್ಲಿರುತ್ತದೆ ಏಕೆಂದರೆ. 

ಬಳಸುವ ಒಂದು ಸಂಕೇತ Θ ಹೊಂದಿದೆ. ಈ ಅಲ್ಲಿ ಉತ್ತಮ ಮತ್ತು ಕೆಟ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ ಕ್ರಮಾವಳಿಗಳು ವಿವರಿಸಲು ಬಳಸಬಹುದು ಒಂದೇ. ನಾವು ಹಿಂದಿನ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದದ ಕ್ರಮಾವಳಿಗಳಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ. ನಾವು ಮೊದಲು ವೇರಿಯಬಲ್ ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು ವೇಳೆ ಅಂದರೆ, ನಾವು ಸ್ಟ್ರಿಂಗ್ ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ನಂತರ ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಪ್ರವೇಶಿಸಲು. ಯಾವ ಸಂಖ್ಯೆಯು ಯಾವುದೇ ನಾವು ವೇರಿಯಬಲ್ ಸಂಗ್ರಹಿಸಲು ನೀವು, ನಾವು ನೋಡಲು ಸಾಧ್ಯವಿದೆ. ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ನೋಡೋಣ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದವನ್ನು ಹೇಗೆ. Ω (1) ಅಥವಾ ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ನಿರಂತರ ಸಮಯ ಆದ್ದರಿಂದ. ಕೆಟ್ಟ ನಿದರ್ಶನವನ್ನು ನಾವು ನೋಡಲು ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದವನ್ನು ಹೇಗೆ. ಆದ್ದರಿಂದ, ಓ (1) ಅಥವಾ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ನಿರಂತರ ಸಮಯ. ಆದ್ದರಿಂದ, ಉತ್ತಮ ಕೇಸ್ ಮತ್ತು ವರ್ಸ್ಟ್ ಸಂದರ್ಭಗಳಲ್ಲಿ ಕಾರಣ, ಒಂದೇ ಈ Θ (1) ಸಮಯ ಚಲಾಯಿಸಲು ಹೇಳಬಹುದು. 

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

ನೀವು ಒ (N) ² ಕ್ರಮಾವಳಿ, ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವ ನೀವು ಅಥವಾ ಕಳಪೆ, ಒಂದು ಒ (2 ⁿ) ಕ್ರಮಾವಳಿ, ವೇಗವಾಗಿ ಬೆಳೆಯುತ್ತಿರುವ ರೀತಿಯ ಒಂದು, ನೀವು ನಿಜವಾಗಿಯೂ ಕುಸಿತ ಗಮನಕ್ಕೆ ಆರಂಭಿಸಲು ಮಾಡುತ್ತೇವೆ ನೀವು ಡೇಟಾವನ್ನು ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಕೆಲಸ ಪ್ರಾರಂಭಿಸಿದಾಗ. 

ಆ ಅಸಂಪಾತ ಸಂಕೀರ್ಣತೆ ಇಲ್ಲಿದೆ. ಧನ್ಯವಾದಗಳು.