Comprehensive Interview Study Guide for Computer Networks, Databases, Data Structures, Linux, OS, Java, and PHP

Computer Networks

1. OSI seven‑layer model and TCP/IP four‑layer model.

2. Network devices corresponding to each layer (router, switch, gateway, bridge, hub, etc.) and the protocols they use.

3. CSMA/CD protocol at the data‑link layer, often asked in written exams.

4. IP address classes and subnetting, frequently tested.

5. Differences between TCP and UDP.

6. TCP three‑way handshake and four‑step termination, including the rationale behind each.

7. Core TCP concepts: stop‑and‑wait, sliding‑window, flow control, congestion control (slow start, congestion avoidance, fast retransmit, fast recovery).

8. Differences between GET and POST requests.

9. HTTP status codes and differences between HTTP/1.0 and HTTP/1.1.

10. HTTP caching mechanisms (Cache‑Control, Expires, etc.).

11. Session vs. cookie, and handling when cookies are disabled.

12. DNS resolution process.

13. Common protocol port numbers.

Recommended reading: "Computer Networks", "TCP/IP Illustrated", "HTTP: The Definitive Guide".

Relational Database – MySQL

1. Database normalization (three normal forms) and ER diagrams.

2. Differences between InnoDB and MyISAM storage engines.

3. Index types (primary, unique, full‑text, covering, etc.), left‑most prefix rule, and conditions that prevent index usage.

4. B‑tree vs. B+‑tree and why indexes use B+‑trees.

5. Clustered vs. non‑clustered indexes (query process for non‑clustered indexes).

6. ACID properties of transactions.

7. Transaction isolation levels, associated problems (dirty read, non‑repeatable read, phantom read) and solutions (gap locks, MVCC).

8. Optimistic vs. pessimistic locking, row vs. table locks, shared vs. exclusive locks (how InnoDB manually acquires shared/exclusive locks).

9. MVCC implementation (two version numbers) and its effect on DELETE, UPDATE, SELECT.

10. Deadlock detection principles and typical scenarios.

11. Slow query analysis and remedies (EXPLAIN, slow‑query log, SHOW PROFILE, etc.).

12. Differences among DROP, TRUNCATE, and DELETE.

13. Execution order of query clauses (WHERE, JOIN, LIMIT, GROUP BY, HAVING, etc.).

14. MySQL performance optimization, read/write splitting, master‑slave replication.

15. Transaction recovery mechanisms during database crash (REDO and UNDO logs).

Non‑Relational Database – Redis

1. High‑availability and clustering mechanisms in Redis.

2. Comparison of Redis and Memcached, including advantages and disadvantages.

3. Data storage types supported by Redis.

4. Common Redis use cases.

5. Persistence methods in Redis and which one is used in typical projects.

Recommended reading: "High Performance MySQL", "Redis Design and Implementation", "Redis in Action".

Data Structures and Algorithms

1. Core structures: arrays, singly/doubly/bidirectional linked lists, stacks, queues, binary trees, red‑black trees, hash tables, max/min heaps.

2. Personal experience: frequent interview questions on stacks, queues, hash tables, linked lists, binary trees; fewer on graphs.

3. Searching techniques: binary search and its variants.

4. Binary tree traversals (pre‑order, in‑order, post‑order), printing formats, and typical problems (lowest common ancestor, distance between nodes).

5. Max‑heap and min‑heap usage for finding top‑k elements and heap adjustments.

6. Stack and queue applications in algorithm problems.

7. Eight sorting algorithms – three simple (bubble, selection, insertion and their optimizations) and five advanced (quick sort, merge sort, heap sort, shell sort, bucket sort); quick sort, merge sort, and heap sort are especially important.

8. Time‑complexity and space‑complexity analysis.

Recommended reading: "Data Structures in C", "Data Structures and Algorithms in Java" (Robert Lafore), "Cracking the Coding Interview", "Introduction to Algorithms".

Linux

1. Common commands for user management, permission control, process control, and system status queries.

2. Purpose of the /etc/hosts file.

3. Linux directory structure, with emphasis on /proc.

4. Linux file system layout and boot process.

5. Java server troubleshooting (OOM, high CPU, high load, class conflicts).

6. How to view Java thread information.

7. Analyzing thread dump files (runnable state, locks, stack traces, mapping to OS thread IDs).

Operating System

1. What the OS does when executing a binary program – a comprehensive overview.

2. Conditions for deadlock and solutions such as the Banker's algorithm and resource‑allocation graphs.

3. Inter‑process communication methods.

4. Five Linux I/O models (blocking vs. non‑blocking, synchronous vs. asynchronous).

5. Differences among select, poll, and epoll.

6. Process vs. thread, kernel‑level vs. user‑level threads.

7. Page replacement algorithms, especially LRU.

8. Process scheduling algorithms.

9. Linux interrupt handling mechanisms.

10. Virtual memory mechanisms.

Basic Languages (Java & PHP)

PHP :

1. Object‑oriented features of PHP and differences from Java.

2. Three pointers inside a PHP class (this, class name, self).

3. PHP autoloading mechanism.

4. Magic methods in PHP.

5. PHP namespaces.

6. PHP garbage collection and its issues (circular references, memory leaks).

7. Preventing SQL injection in PHP (prepared statements with mysqli, etc.).

8. Integration of PHP with Apache.

9. FastCGI and php‑fpm ports and operation modes.

10. Advantages and principles of Nginx over Apache (memory‑mapped files, event‑driven, AIO).

Java :

1. Core object‑oriented concepts.

2. Thread creation methods (Thread, Runnable, Callable, thread pools) and their characteristics.

3. Thread states and transitions.

4. Thread synchronization techniques and inter‑thread communication.

5. Internal implementations of ArrayList and LinkedList, their differences, pros and cons.

6. HashMap implementation and how to achieve thread safety.

7. JVM memory layout and the need for garbage collection.

8. Garbage‑collection mechanisms and algorithms in the JVM.

9. Triggers for Young GC vs. Full GC.

10. JVM memory tuning and diagnosing memory leaks.

11. Principle of Spring IoC.

12. Implementing an aspect in Spring.

13. Transaction management in Spring.

14. Common design patterns, writing a singleton, and patterns used inside JDK and Spring.

15. Relationship between multithreading and high concurrency.

16. Typical high‑concurrency scenarios and corresponding architectural solutions.

17. Overview of distributed middleware, their use cases, and functions.

18. Design ideas for a Double‑11 flash‑sale system architecture.

PS: If you find this useful, please like and share to support.