ਇੱਕ ਡੇਟਾ ਢਾਂਚਾ ਮੈਮੋਰੀ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਅਤੇ ਸਟੋਰ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ ਤਾਂ ਜੋ ਇਸ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਐਕਸੈਸ ਅਤੇ ਸੰਸ਼ੋਧਿਤ ਕੀਤਾ ਜਾ ਸਕੇ। ਇੱਕ ਐਬਸਟ੍ਰੈਕਟ ਡੇਟਾ ਕਿਸਮ (ADT) ਲੌਜ਼ੀਕਲ ਮਾਡਲ ਹੈ — ਓਪਰੇਸ਼ਨ ਅਤੇ ਉਨ੍ਹਾਂ ਦਾ ਵਰਤਾਓ — ਇਸ ਤੋਂ ਸੁਤੰਤਰ ਕਿ ਇਹ ਕਿਵੇਂ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ADT ਓਪਰੇਸ਼ਨ ਮੌਜੂਦ ਹਨ ਇਸ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ; ਡੇਟਾ ਢਾਂਚਾ ਉਨ੍ਹਾਂ ਨੂੰ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਉਹ ਕਿਨੀ ਤੇਜ਼ੀ ਨਾਲ ਚਲਦੇ ਹਨ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ।
ADT: Stack → push, pop, peek (LIFO behavior)
Implementations: → array-backed OR linked-list-backed
ADT: List → get(i), insert, remove
Implementations: → dynamic array OR linked list
# Both satisfy the "Stack" ADT, but have different cost profiles
stack = [] # list-backed stack
stack.append(10) # push -> amortized O(1)
top = stack[-1] # peek -> O(1)
stack.pop() # pop -> O(1)
| ਚਿੰਤਾ | ਪੁੱਛਣ ਲਈ ਸਵਾਲ |
|---|---|
| ਪਹੁੰਚ ਪੈਟਰਨ | ਬੇਤਰਤੀਬ ਪਹੁੰਚ ਜਾਂ ਕ੍ਰਮਾਂਕਿਤ? |
| ਪਰਿਵਰਤਨ | ਮੱਧ ਵਿੱਚ ਅਕਸਰ ਸੰਮਿਲਿਤ/ਹਟਾਇਆ ਜਾਂਦਾ ਹੈ? |
| ਕ੍ਰਮਬੱਧਤਾ | ਸਾਵ, FIFO, LIFO, ਜਾਂ ਕੋਈ ਨਹੀਂ? |
| ਲੁਕ-ਅੱਪ | ਇਨਡੈਕਸ ਦੁਆਰਾ ਜਾਂ ਕੁੰਜੀ ਦੁਆਰਾ? |
ਸਹੀ ਚੋਣ ਉਹ ਹੈ ਜਿਸ ਦੇ ਆਮ ਓਪਰੇਸ਼ਨ ਸਸਤੇ ਹਨ ਤੁਹਾਡੀ ਕਾਰਜ ਲੋਡ ਲਈ।
ਗ਼ਲਤ ਢਾਂਚਾ ਚੁਣਨਾ O(1) ਓਪਰੇਸ਼ਨ ਨੂੰ O(n) ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ, ਜੋ ਸਕੇਲ 'ਤੇ ਕੋਡ ਨੂੰ ਹਜ਼ਾਰਾਂ ਗੁਣਾ ਹੌਲੀ ਕਰ ਸਕਦਾ ਹੈ।
ADT ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਸੋਚਣਾ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਵਰਤਾਓ ਬਾਰੇ ਤਰਕ ਕਰਨ ਦਿੰਦਾ ਹੈ, ਫਿਰ ਬਾਅਦ ਵਿੱਚ ਕਾਲਰਾਂ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੇ ਬਿਨਾਂ ਲਾਗੂ ਕਰਨਾ ਬਦਲ ਸਕਦਾ ਹੈ।