Quicksort is an efficient sorting algorithm with an average time complexity of O(n log n), and its core lies in the division and governance strategy and recursion logic. 1. Select the reference value (usually the last element); 2. Place the number less than or equal to the reference to the left and the one greater than the right; 3. Perform the above steps recursively on the left and right subarrays. The key to implementation lies in the partition function, which returns the final position of the reference value and correctly divides the array, while handling duplicate elements and swap operations. Optimization suggestions include avoiding worst pivot selection, switching insertion sorting of small arrays, and considering the use of merge sorting of object arrays in Java for stability. Mastering these key points can achieve an efficient and usable quicksort.
Quicksort is an efficient sorting algorithm with an average time complexity of O(n log n), which is very commonly used in actual programming. It is not difficult to implement it, the key is to understand its division and governance ideas and recursive logic.
Basic ideas: select benchmarks, divide left and right, and recursively arrange them
The core of Quicksort is the "dividing and consolidation" strategy. The general steps are as follows:
- Select a "base value" from the array (pivot)
- Put all numbers smaller than the benchmark to the left and the larger ones to the right
- Recursively execute the above process on the left and right subarrays
The key point of this algorithm is how to divide the array. You can select the first element, the last element, or the intermediate element as pivot. A common practice is to choose the last element.
Implementation key points: How to write partition function?
In Java, quicksort is the most important thing to write a good partition function. Here is a more general writing method:
private int partition(int[] arr, int low, int high) {
int pivot = arr[high]; // Select the last element as the reference int i = low - 1; // i represents the last position of the area smaller than pivot for (int j = low; j < high; j ) {
if (arr[j] <= pivot) {
i ;
swap(arr, i, j);
}
}
swap(arr, i 1, high); // Put pivot in the correct position return i 1;
} The function of this function is to divide the array into two parts and return to the final position of pivot. Note that the loop judgment condition here is arr[j] <= pivot , so that the case of repeated elements can be handled.
Don't forget to write a helper function to exchange elements:
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}Complete implementation: Add recursive main function
With the partition function, you can write the complete quicksort method:
public void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1); // row left quickSort(arr, pi 1, high); // row right}
}When calling, you only need to pass in the array and the start and end index:
int[] nums = {9, 7, 5, 11, 12, 2, 14, 3, 10, 6};
quickSort(nums, 0, nums.length - 1);Tips: Precautions and optimization suggestions
- When the array is empty or the length is 1, return in advance to avoid crossing the boundary.
- Avoid choosing the worst pivot every time (such as the array is already ordered), you can use a random method to select pivot to improve performance.
- For small arrays (such as length less than 10), switching to insert sort may be faster
- In Java, basic type array sorting uses fast sorting in place, while object arrays are recommended to use merge sorting because stable sorting is required.
For example, Arrays.sort() in the Java standard library uses a variant of quick sorting for int[] .
Basically that's it. By mastering these key points, you can write a quicksort implementation that can run and use.
The above is the detailed content of How to implement a quicksort algorithm in Java?. For more information, please follow other related articles on the PHP Chinese website!
Hot AI Tools
Undress AI Tool
Undress images for free
Undresser.AI Undress
AI-powered app for creating realistic nude photos
AI Clothes Remover
Online AI tool for removing clothes from photos.
Clothoff.io
AI clothes remover
Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!
Hot Article
Hot Tools
Notepad++7.3.1
Easy-to-use and free code editor
SublimeText3 Chinese version
Chinese version, very easy to use
Zend Studio 13.0.1
Powerful PHP integrated development environment
Dreamweaver CS6
Visual web development tools
SublimeText3 Mac version
God-level code editing software (SublimeText3)
Asynchronous Programming Techniques in Modern Java
Jul 07, 2025 am 02:24 AM
Java supports asynchronous programming including the use of CompletableFuture, responsive streams (such as ProjectReactor), and virtual threads in Java19. 1.CompletableFuture improves code readability and maintenance through chain calls, and supports task orchestration and exception handling; 2. ProjectReactor provides Mono and Flux types to implement responsive programming, with backpressure mechanism and rich operators; 3. Virtual threads reduce concurrency costs, are suitable for I/O-intensive tasks, and are lighter and easier to expand than traditional platform threads. Each method has applicable scenarios, and appropriate tools should be selected according to your needs and mixed models should be avoided to maintain simplicity
Best Practices for Using Enums in Java
Jul 07, 2025 am 02:35 AM
In Java, enums are suitable for representing fixed constant sets. Best practices include: 1. Use enum to represent fixed state or options to improve type safety and readability; 2. Add properties and methods to enums to enhance flexibility, such as defining fields, constructors, helper methods, etc.; 3. Use EnumMap and EnumSet to improve performance and type safety because they are more efficient based on arrays; 4. Avoid abuse of enums, such as dynamic values, frequent changes or complex logic scenarios, which should be replaced by other methods. Correct use of enum can improve code quality and reduce errors, but you need to pay attention to its applicable boundaries.
Understanding Java NIO and Its Advantages
Jul 08, 2025 am 02:55 AM
JavaNIO is a new IOAPI introduced by Java 1.4. 1) is aimed at buffers and channels, 2) contains Buffer, Channel and Selector core components, 3) supports non-blocking mode, and 4) handles concurrent connections more efficiently than traditional IO. Its advantages are reflected in: 1) Non-blocking IO reduces thread overhead, 2) Buffer improves data transmission efficiency, 3) Selector realizes multiplexing, and 4) Memory mapping speeds up file reading and writing. Note when using: 1) The flip/clear operation of the Buffer is easy to be confused, 2) Incomplete data needs to be processed manually without blocking, 3) Selector registration must be canceled in time, 4) NIO is not suitable for all scenarios.
How Java ClassLoaders Work Internally
Jul 06, 2025 am 02:53 AM
Java's class loading mechanism is implemented through ClassLoader, and its core workflow is divided into three stages: loading, linking and initialization. During the loading phase, ClassLoader dynamically reads the bytecode of the class and creates Class objects; links include verifying the correctness of the class, allocating memory to static variables, and parsing symbol references; initialization performs static code blocks and static variable assignments. Class loading adopts the parent delegation model, and prioritizes the parent class loader to find classes, and try Bootstrap, Extension, and ApplicationClassLoader in turn to ensure that the core class library is safe and avoids duplicate loading. Developers can customize ClassLoader, such as URLClassL
How does a HashMap work internally in Java?
Jul 15, 2025 am 03:10 AM
HashMap implements key-value pair storage through hash tables in Java, and its core lies in quickly positioning data locations. 1. First use the hashCode() method of the key to generate a hash value and convert it into an array index through bit operations; 2. Different objects may generate the same hash value, resulting in conflicts. At this time, the node is mounted in the form of a linked list. After JDK8, the linked list is too long (default length 8) and it will be converted to a red and black tree to improve efficiency; 3. When using a custom class as a key, the equals() and hashCode() methods must be rewritten; 4. HashMap dynamically expands capacity. When the number of elements exceeds the capacity and multiplies by the load factor (default 0.75), expand and rehash; 5. HashMap is not thread-safe, and Concu should be used in multithreaded
Effective Use of Java Enums and Best Practices
Jul 07, 2025 am 02:43 AM
Java enumerations not only represent constants, but can also encapsulate behavior, carry data, and implement interfaces. 1. Enumeration is a class used to define fixed instances, such as week and state, which is safer than strings or integers; 2. It can carry data and methods, such as passing values ??through constructors and providing access methods; 3. It can use switch to handle different logics, with clear structure; 4. It can implement interfaces or abstract methods to make differentiated behaviors of different enumeration values; 5. Pay attention to avoid abuse, hard-code comparison, dependence on ordinal values, and reasonably naming and serialization.
How to handle exceptions properly in Java?
Jul 06, 2025 am 02:43 AM
The key to handling exceptions in Java is to catch them, handle them clearly, and not cover up problems. First, we must catch specific exception types as needed, avoid general catches, and prioritize checkedexceptions. Runtime exceptions should be judged in advance; second, we must use the log framework to record exceptions, and retry, rollback or throw based on the type; third, we must use the finally block to release resources, and recommend try-with-resources; fourth, we must reasonably define custom exceptions, inherit RuntimeException or Exception, and carry context information for easy debugging.
What is a Singleton design pattern in Java?
Jul 09, 2025 am 01:32 AM
Singleton design pattern in Java ensures that a class has only one instance and provides a global access point through private constructors and static methods, which is suitable for controlling access to shared resources. Implementation methods include: 1. Lazy loading, that is, the instance is created only when the first request is requested, which is suitable for situations where resource consumption is high and not necessarily required; 2. Thread-safe processing, ensuring that only one instance is created in a multi-threaded environment through synchronization methods or double check locking, and reducing performance impact; 3. Hungry loading, which directly initializes the instance during class loading, is suitable for lightweight objects or scenarios that can be initialized in advance; 4. Enumeration implementation, using Java enumeration to naturally support serialization, thread safety and prevent reflective attacks, is a recommended concise and reliable method. Different implementation methods can be selected according to specific needs
