ఈ పాఠం స్వయంచాలకంగా తెలుగులోకి అనువదించబడింది, ఇంకా ఎవరూ సమీక్షించలేదు. ఏదైనా వింతగా అనిపిస్తే, ఇంగ్లీష్ మూలమే ప్రామాణికం.
అగ్ర ఇంటర్వ్యూ కోచ్‌లు తెలుసుకోవడానికి మీకు $500 వసూలు చేయరనే రహస్యం ఇక్కడ ఉంది: దాదాపు 90% కోడింగ్ ఇంటర్వ్యూ సమస్యలు కేవలం ఏడు డేటా స్ట్రక్చర్‌ల చుట్టూ తిరుగుతాయి. ప్రతి ఒక్కటి ఎప్పుడు మరియు ఎందుకు చేరుకోవాలో మీరు లోతుగా అర్థం చేసుకుంటే, మీరు ఇప్పటికే సగం యుద్ధంలో గెలిచారు. మిగిలిన సగం అభ్యాసం - కానీ సరైన మానసిక నమూనాలు లేకుండా, అభ్యాసం కేవలం కంఠస్థం. ఈ పాఠం మీకు మ్యాప్‌ని అందిస్తుంది కాబట్టి మీరు ఎదుర్కొనే ప్రతి సమస్య తెలిసిన ప్రాంతంగా అనిపిస్తుంది.
ప్రతి సాంకేతిక ఇంటర్వ్యూ అదే బావి నుండి తీసుకోబడుతుంది. ఫ్రీక్వెన్సీ ఆధారంగా మీరు ఎదుర్కొనే నిర్మాణాలు ఇక్కడ ఉన్నాయి:
| డేటా నిర్మాణం | ఇంటర్వ్యూ ఫ్రీక్వెన్సీ | కోర్ ఆపరేషన్స్ | ఇంటర్వ్యూయర్లు ఆశించినప్పుడు | |---|---|---|---| | శ్రేణులు / స్ట్రింగ్స్ | ★★★★★ | యాక్సెస్ O(1), శోధన O(n), O(n) | చొప్పించు దాదాపు ప్రతి సమస్య ఇక్కడే మొదలవుతుంది | | హాష్ మ్యాప్స్ / సెట్‌లు | ★★★★★ | O(1), లుక్అప్ O(1), తొలగించు O(1) | "దీన్ని O(n²) నుండి O(n)కి ఆప్టిమైజ్ చేయండి" | | లింక్ చేయబడిన జాబితాలు | ★★★★☆ | O(1)ని చొప్పించండి, O(1ని తొలగించండి), O(n)ని యాక్సెస్ చేయండి | పాయింటర్ మానిప్యులేషన్, సైకిల్ డిటెక్షన్ | | స్టాక్స్ & క్యూలు | ★★★★☆ | పుష్/పాప్ ఓ(1), ఎన్‌క్యూ/డీక్యూ ఓ(1) | పార్సింగ్, BFS, ఆపరేషన్‌లను రద్దు చేయండి | | చెట్లు (బైనరీ, BST) | ★★★★☆ | O(లాగ్ n), చొప్పించు O(లాగ్ n) | క్రమానుగత డేటా, క్రమబద్ధీకరించబడిన కార్యకలాపాలు | | గ్రాఫ్‌లు | ★★★☆☆ | ప్రాతినిధ్యంపై ఆధారపడి ఉంటుంది | సంబంధాలు, మార్గాలు, కనెక్టివిటీ | | కుప్పలు | ★★★☆☆ | చొప్పించు O(లాగ్ n), Extract-నిమి O(లాగ్ n) | "కె పెద్దది/చిన్నది కనుగొనండి" |
దాదాపు ప్రతి ఇంటర్వ్యూ సమస్యకు శ్రేణులు ప్రారంభ స్థానం. ప్రధాన అంతర్దృష్టి ఏమిటంటే, చాలా శ్రేణి సమస్యలు నిజంగా శ్రేణుల గురించి కాదు - అవి రెండు పాయింటర్‌లు, స్లైడింగ్ విండో లేదా ప్రిఫిక్స్ మొత్తాల వంటి నమూనాలను గుర్తించడం.
# Two Sum — the most classic interview problem
# "Given an array and target, find two numbers that add to target"
def two_sum(nums, target):
seen = {} # Hash map to store complement
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return []
# Time: O(n), Space: O(n) — trading space for time
ఈ "అరే" సమస్య కూడా నిజంగా హాష్ మ్యాప్ సమస్యగా ఎలా ఉందో గమనించండి. ఆ నమూనా నిరంతరం పునరావృతమవుతుంది: బ్రూట్ ఫోర్స్ శ్రేణిపై సమూహ లూప్‌లను ఉపయోగిస్తుంది మరియు సరైన పరిష్కారం హాష్ మ్యాప్‌ను పరిచయం చేస్తుంది.
సైన్ ఇన్ చేయండి చర్చలో పాల్గొనడానికి
మీరు ఏదైనా సమస్యలో చిక్కుకుపోయి, బ్రూట్ ఫోర్స్ O(n²) అయితే, మిమ్మల్ని మీరు ఇలా ప్రశ్నించుకోండి: "హాష్ మ్యాప్ దీన్ని O(n)కి తగ్గించగలదా?" సమాధానం ఆశ్చర్యకరంగా తరచుగా అవును.
మీకు అవసరమైనప్పుడు హాష్ మ్యాప్‌లు మెరుస్తాయి:
// Group Anagrams — a classic hash map problem
public List<List<String>> groupAnagrams(String[] strs) {
Map<String, List<String>> map = new HashMap<>();
for (String s : strs) {
char[] chars = s.toCharArray();
Arrays.sort(chars);
String key = new String(chars);
map.computeIfAbsent(key, k -> new ArrayList<>()).add(s);
}
return new ArrayList<>(map.values());
}
లింక్డ్ జాబితా సమస్యలు నోడ్‌ల ట్రాక్‌ను కోల్పోకుండా పాయింటర్‌లను మార్చగల మీ సామర్థ్యాన్ని పరీక్షిస్తాయి. మీకు అవసరమైన మూడు సాంకేతికతలు:
# Detect a cycle in a linked list (Floyd's Algorithm)
def has_cycle(head):
slow = fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast:
return True
return False
స్టాక్‌లు (LIFO) మరియు క్యూలు (FIFO) సరళమైన నిర్మాణాలు, కానీ అవి మొత్తం సమస్యల వర్గాలను అన్‌లాక్ చేస్తాయి:
# Valid Parentheses — classic stack problem
def is_valid(s: str) -> bool:
stack = []
matching = {')': '(', '}': '{', ']': '['}
for char in s:
if char in matching:
if not stack or stack[-1] != matching[char]:
return False
stack.pop()
else:
stack.append(char)
return len(stack) == 0
చెట్ల సమస్యలు సాధారణంగా పునరావృతం మరియు మూడు ట్రావెర్సల్ ఆర్డర్‌లలో ఒకటి (ఇన్-ఆర్డర్, ప్రీ-ఆర్డర్, పోస్ట్-ఆర్డర్) కలిగి ఉంటాయి. అభివృద్ధి చేయవలసిన మానసిక నమూనా: "ఎడమ సబ్‌ట్రీ, కుడి సబ్‌ట్రీ నుండి నాకు ఏమి కావాలి మరియు ప్రస్తుత నోడ్‌లో వాటిని ఎలా కలపాలి?"
# Maximum depth of a binary tree — the template for tree recursion
def max_depth(root):
if not root:
return 0
left_depth = max_depth(root.left)
right_depth = max_depth(root.right)
return 1 + max(left_depth, right_depth)
BST (బైనరీ సెర్చ్ ట్రీ) సమస్యలు ఒక కీలకమైన ప్రాపర్టీని జోడిస్తాయి: ఇన్-ఆర్డర్ ట్రావెర్సల్ క్రమబద్ధీకరించబడిన మూలకాలను అందిస్తుంది. మీకు ఒకే సమస్యలో "క్రమబద్ధీకరించబడినది" మరియు "చెట్టు" కనిపిస్తే, వెంటనే BSTని ఆలోచించండి.
గ్రాఫ్ సమస్యలు బెదిరింపుగా అనిపిస్తాయి కానీ మీరు ప్రక్కనే ఉన్న జాబితాను రూపొందించిన తర్వాత చాలా వరకు BFS లేదా DFSకి తగ్గుతాయి. ప్రధాన నైపుణ్యాలు:
# BFS shortest path in an unweighted graph
from collections import deque
def shortest_path(graph, start, end):
queue = deque([(start, 0)])
visited = {start}
while queue:
node, distance = queue.popleft()
if node == end:
return distance
for neighbour in graph[node]:
if neighbour not in visited:
visited.add(neighbour)
queue.append((neighbour, distance + 1))
return -1 # Not reachable
"K అతిపెద్దది కనుగొనండి", "K దగ్గరగా" లేదా "K క్రమబద్ధీకరించబడిన జాబితాలను విలీనం చేయండి" అని ఏదైనా సమస్య చెప్పినప్పుడు, ఒక కుప్ప (ప్రాధాన్యత క్యూ) దాదాపుగా సమాధానం అవుతుంది. పైథాన్‌లో, heapq నిమి-హీప్ని అందిస్తుంది; గరిష్ట-కుప్ప కోసం, విలువలను తిరస్కరించండి.
import heapq
# Find the K largest elements in an array
def k_largest(nums, k):
return heapq.nlargest(k, nums) # Uses a min-heap of size k internally
మీరు ప్రతి చొప్పించడం కోసం O(లాగ్ n)లో సంఖ్యల స్ట్రీమ్ మధ్యస్థాన్ని కనుగొనాలి. ఏ డేటా స్ట్రక్చర్ కాంబినేషన్ అత్యంత సముచితమైనది?
| నిర్మాణం | యాక్సెస్ | శోధన | చొప్పించు | తొలగించు | స్పేస్ | |---|---|---|---|---|---| | అర్రే | O(1) | O(n) | O(n) | O(n) | O(n) | | హాష్ మ్యాప్ | — | O(1)* | O(1)* | O(1)* | O(n) | | లింక్డ్ లిస్ట్ | O(n) | O(n) | O(1) | O(1) | O(n) | | స్టాక్/క్యూ | O(n) | O(n) | O(1) | O(1) | O(n) | | BST (సమతుల్యత) | O(లాగ్ n) | O(లాగ్ n) | O(లాగ్ n) | O(లాగ్ n) | O(n) | | కుప్ప | — | O(n) | O(లాగ్ n) | O(లాగ్ n) | O(n) |
* సగటు కేసు; హాష్ తాకిడి కారణంగా O(n) చెత్త కేసు.
సమస్యను చదివేటప్పుడు ఈ మానసిక తనిఖీ జాబితాను అభివృద్ధి చేయండి: