数据结构第20节 快速排序以及优化

最新推荐文章于 2024-11-18 00:00:00 发布
最新推荐文章于 2024-11-18 00:00:00 发布
阅读量1.3k 收藏 26
点赞数 32
文章标签： 数据结构 算法 排序算法 java spring maven java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hummhumm/article/details/140350373
版权

快速排序是一种非常高效的排序算法，由英国计算机科学家托尼·霍尔（Tony Hoare）在1960年代发明。它使用分治法（Divide and Conquer）策略来把一个序列分为较小的部分，然后递归地排序这些部分。

快速排序的基本步骤：

  1. 选择基准值（Pivot Selection）：从序列中选择一个元素作为基准值。通常选择序列的第一个、最后一个或中间的元素，也可以随机选择。
  2. 分区操作（Partitioning）：重新排列序列，使得所有小于基准值的元素都位于基准值的左边，所有大于基准值的元素都位于基准值的右边。完成这个操作后，基准值就位于最终排序后的位置。
  3. 递归排序子序列：递归地对基准值左边和右边的子序列应用快速排序算法。

分区操作细节：

  • 设置两个指针 left 和 right，left 指针从序列的起始位置开始，right 指针从序列的结束位置开始。
  • 移动 right 指针，直到找到一个小于或等于基准值的元素。
  • 移动 left 指针，直到找到一个大于或等于基准值的元素。
  • 如果 left 指针在 right 指针的左边，交换两个指针所指向的元素。
  • 重复上述步骤，直到 left 和 right 指针相遇或交叉。
  • 当指针交叉时，将基准值与 right 指针所指向的元素交换，完成分区操作。

Java代码实现：

下面是一个简单的快速排序算法的Java实现：

public class QuickSort {

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            // pi is partitioning index, arr[pi] is now at right place
            int pi = partition(arr, low, high);

            // Recursively sort elements before and after partition
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high]; // pivot
        int i = (low - 1); // Index of smaller element

        for (int j = low; j < high; j++) {
            // If current element is smaller than the pivot
            if (arr[j] < pivot) {
                i++;

                // swap arr[i] and arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        // swap arr[i+1] and arr[high] (or pivot)
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;

        return i + 1;
    }

    // Function to print an array
    public static void printArray(int[] arr) {
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        int n = arr.length;

        quickSort(arr, 0, n - 1);

        System.out.println("Sorted array:");
        printArray(arr);
    }
}

时间复杂度：

  • 最佳和平均情况：O(n log n)
  • 最差情况：O(n^2)，当输入数组已经是排序好的或逆序的，基准值每次都是最小或最大值。

空间复杂度：

  • O(log n)，由于递归调用栈的空间。

快速排序在实际应用中非常广泛，尤其是在大规模数据集上，因为它能够提供非常好的性能。然而，在某些情况下，例如数据已经接近排序的情况下，快速排序的性能可能会退化，这时可以考虑使用其他排序算法，如堆排序或归并排序。

要优化快速排序算法，我们可以采取几种不同的策略来提高其效率和稳定性。以下是一些常见的改进方法：

  1. 三数取中法（Median-of-three）选择基准值：
    在选择基准值时，使用数组的第一个元素、中间元素和最后一个元素中的中位数作为基准值，这有助于避免最坏情况的发生，特别是在数组已经部分排序的情况下。

  2. 插入排序小数组：
    对于小规模的子数组，使用插入排序替换快速排序。插入排序在小数组上的性能通常优于快速排序，因为它的常数因子较小。

  3. 尾递归优化：
    可以优化递归调用，减少栈空间的使用。具体来说，你可以先递归处理较大的子数组，然后迭代处理较小的子数组，或者使用循环结构替代递归。

  4. 非递归版本：
    使用显式栈来模拟递归调用，这样可以避免系统调用栈的开销。

下面是使用三数取中法和插入排序小数组的优化版快速排序示例代码：

public class OptimizedQuickSort {

    public static void quickSort(int[] arr, int low, int high) {
        while (low < high) {
            // Partition and get the partition index.
            int pi = partition(arr, low, high);

            // Recursively sort the left part, but only if it's larger than the right.
            if (pi - low < high - pi) {
                quickSort(arr, low, pi - 1);
                low = pi + 1;
            } else {
                quickSort(arr, pi + 1, high);
                high = pi - 1;
            }
        }
    }

    private static int partition(int[] arr, int low, int high) {
        // Median-of-three pivot selection
        int mid = (low + high) / 2;
        if (arr[mid] > arr[high]) {
            swap(arr, mid, high);
        }
        if (arr[low] > arr[high]) {
            swap(arr, low, high);
        }
        if (arr[mid] > arr[low]) {
            swap(arr, mid, low);
        }
        
        int pivot = arr[low];
        int i = low + 1;
        int j = high;

        while (true) {
            while (i <= j && arr[i] <= pivot) {
                i++;
            }
            while (i <= j && arr[j] >= pivot) {
                j--;
            }
            if (i <= j) {
                swap(arr, i, j);
            } else {
                break;
            }
        }

        swap(arr, low, j);
        return j;
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void insertionSort(int[] arr, int low, int high) {
        for (int i = low + 1; i <= high; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= low && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        int n = arr.length;

        // Optimize: Use insertion sort for small subarrays
        for (int i = 0; i < n; i += 16) {
            insertionSort(arr, i, Math.min((i + 15), (n - 1)));
        }

        quickSort(arr, 0, n - 1);

        System.out.println("Sorted array:");
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

在这个优化版本中，我们使用了三数取中法来选择更合理的基准值，并且对于小于16个元素的小数组使用插入排序进行排序。此外，我们还通过循环结构代替递归来减少栈的使用。这些修改可以帮助提高快速排序在各种情况下的性能和稳定性。

尾递归优化

尾递归优化是指在递归函数中，如果递归调用是函数执行的最后一个操作，那么可以通过一些技巧将其转换为迭代，从而避免栈溢出的风险和减少递归调用的开销。对于快速排序而言，可以优先递归处理较小的子数组，然后返回处理较大的子数组，这样可以保证递归深度不会过大。

下面是一个利用尾递归优化的快速排序Java实现示例：

public class TailRecursiveQuickSort {

    public static void quickSort(int[] arr, int low, int high) {
        while (low < high) {
            // Partitioning index
            int pi = partition(arr, low, high);

            // Recursively sort elements before partition and after partition
            if (pi - low < high - pi) {
                // Sort the smaller part first
                quickSort(arr, low, pi - 1);
                // Update the range for the larger part
                low = pi + 1;
            } else {
                // Sort the larger part first
                quickSort(arr, pi + 1, high);
                // Update the range for the smaller part
                high = pi - 1;
            }
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = (low - 1); // index of smaller element
        for (int j = low; j < high; j++) {
            // If current element is smaller than or equal to pivot
            if (arr[j] <= pivot) {
                i++;

                // swap arr[i] and arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        // swap arr[i+1] and arr[high] (or pivot)
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;

        return i + 1;
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        int n = arr.length;

        quickSort(arr, 0, n - 1);

        System.out.println("Sorted array:");
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

在这个版本中，quickSort 函数使用了一个循环来处理子数组的排序。在每次循环中，它首先对当前的子数组进行分区操作，然后根据左右两部分的大小决定先递归处理哪一部分。这样做可以确保每次递归调用之后，剩余需要处理的子数组的大小总是比前一次小，从而减少了递归的深度。

然而，值得注意的是，尽管这种优化减少了递归调用的次数，但在最坏情况下，如果每次分区都偏向一侧，递归深度仍然可能较大。因此，结合其他优化策略，如三数取中法选择基准值，可以进一步提高算法的稳定性和性能。

为了进一步提高快速排序的稳定性和性能，可以结合多种优化策略。以下是几种常见的改进方法：

  1. 三数取中法选择基准值：选取第一个、中间的和最后一个元素中的中值作为基准值，以减少最坏情况的发生。

  2. 插入排序小数组：对于小规模的子数组，使用插入排序。插入排序在小数组上的效率高于快速排序。

  3. 随机化基准值选择：随机选择数组中的一个元素作为基准值，可以避免最坏情况的发生，尤其是当数组已部分排序时。

  4. 双路快速排序（Dual-Pivot QuickSort）：同时使用两个基准值，可以减少比较和交换的次数，从而提高性能。

  5. 尾递归优化：减少递归调用的深度，使用循环结构替代递归。

  6. 并行化：利用多核处理器的优势，使用并行计算技术对子数组进行排序。

下面是一个结合了三数取中法、插入排序小数组和尾递归优化的快速排序Java实现：

public class OptimizedQuickSort {

    private static final int INSERTION_SORT_THRESHOLD = 16; // 阈值用于插入排序

    public static void quickSort(int[] arr, int low, int high) {
        while (low < high) {
            // 使用三数取中法选择基准值
            int pivotIndex = medianOfThree(arr, low, high);
            int pivot = arr[pivotIndex];

            // 将基准值放到最后
            swap(arr, pivotIndex, high);

            // Partitioning index
            int pi = partition(arr, low, high);

            // Recursively sort elements before partition and after partition
            if (pi - low < high - pi) {
                // Sort the smaller part first
                quickSort(arr, low, pi - 1);
                // Update the range for the larger part
                low = pi + 1;
            } else {
                // Sort the larger part first
                quickSort(arr, pi + 1, high);
                // Update the range for the smaller part
                high = pi - 1;
            }
        }
    }

    private static int medianOfThree(int[] arr, int low, int high) {
        int mid = (low + high) >>> 1; // 使用无符号右移获得中间索引
        if (arr[mid] > arr[high]) {
            swap(arr, mid, high);
        }
        if (arr[low] > arr[high]) {
            swap(arr, low, high);
        }
        if (arr[mid] > arr[low]) {
            swap(arr, mid, low);
        }
        return low; // 返回中位数的索引
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] <= pivot) {
                i++;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, high);
        return i + 1;
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void insertionSort(int[] arr, int low, int high) {
        for (int i = low + 1; i <= high; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= low && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        int n = arr.length;

        // 使用插入排序处理小数组
        for (int i = 0; i < n; i += INSERTION_SORT_THRESHOLD) {
            insertionSort(arr, i, Math.min(i + INSERTION_SORT_THRESHOLD - 1, n - 1));
        }

        // 使用快速排序处理大数组
        quickSort(arr, 0, n - 1);

        System.out.println("Sorted array:");
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

这个版本的快速排序算法结合了多种优化策略，提高了排序的性能和稳定性。在实际应用中，根据数据的特点和环境的限制，还可以尝试其他的优化策略以达到最佳效果。例如，对于大规模数据集，可以考虑使用并行快速排序来充分利用多核处理器的能力。

在Java中，利用并行流（parallel streams）或java.util.concurrent包中的工具可以实现并行快速排序。这里，我将展示如何使用Fork/Join框架来实现并行快速排序。

Fork/Join框架是Java 7引入的一种并行编程模型，它允许任务被分割成更小的任务，然后并行执行。在快速排序中，我们可以将大的数组分割成小的子数组，并在不同的线程上并行地对它们进行排序。

下面是一个使用Fork/Join框架的并行快速排序实现：

import java.util.Arrays;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.ForkJoinPool;

public class ParallelQuickSort {

    public static void main(String[] args) {
        int[] arr = new int[1_000_000];
        // 初始化数组...
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random() * 1000);
        }

        long startTime = System.currentTimeMillis();

        ForkJoinPool pool = new ForkJoinPool();
        pool.invoke(new SortTask(arr, 0, arr.length - 1));

        long endTime = System.currentTimeMillis();
        System.out.println("Sorting took " + (endTime - startTime) + " ms");

        // 检查排序是否正确
        boolean isSorted = true;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < arr[i - 1]) {
                isSorted = false;
                break;
            }
        }
        System.out.println("Is sorted: " + isSorted);
    }

    static class SortTask extends RecursiveAction {
        private final int[] arr;
        private final int low;
        private final int high;

        public SortTask(int[] arr, int low, int high) {
            this.arr = arr;
            this.low = low;
            this.high = high;
        }

        @Override
        protected void compute() {
            if (low < high) {
                int pi = partition(arr, low, high);
                invokeAll(new SortTask(arr, low, pi - 1), new SortTask(arr, pi + 1, high));
            }
        }

        private int partition(int[] arr, int low, int high) {
            int pivot = arr[high];
            int i = (low - 1); // index of smaller element
            for (int j = low; j < high; j++) {
                // If current element is smaller than or equal to pivot
                if (arr[j] <= pivot) {
                    i++;

                    // swap arr[i] and arr[j]
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }

            // swap arr[i+1] and arr[high] (or pivot)
            int temp = arr[i + 1];
            arr[i + 1] = arr[high];
            arr[high] = temp;

            return i + 1;
        }
    }
}

在上述代码中，SortTask继承自RecursiveAction类，这是Fork/Join框架中的一个抽象类，用于表示一个可并行执行的任务。compute方法定义了任务的执行逻辑。当一个SortTask实例被创建并提交给ForkJoinPool时，它会根据子任务的大小决定是继续分割任务还是直接执行。如果任务足够小，它将直接进行排序；如果任务足够大，它将被分割成更小的子任务，并在多个线程上并行执行。

这种方法特别适用于多核处理器，因为它能有效利用所有可用的CPU核心。但是，对于较小的数据集，由于启动额外线程的开销，传统的单线程排序可能会更快。因此，在实际应用中，你可能还需要调整任务分割的阈值，以找到最适合特定硬件配置的平衡点。

优化后的非递归版本的快速排序算法通常使用显式栈来模拟递归调用的行为，从而避免了递归调用带来的栈溢出风险以及函数调用的开销。下面是一个使用显式栈的非递归快速排序算法的Java实现：

import java.util.ArrayDeque;
import java.util.Deque;

public class NonRecursiveQuickSort {

    public static void quickSort(int[] arr) {
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(0);
        stack.push(arr.length - 1);

        while (!stack.isEmpty()) {
            int high = stack.pop();
            int low = stack.pop();

            int pivotIndex = partition(arr, low, high);

            if (pivotIndex - 1 > low) {
                stack.push(low);
                stack.push(pivotIndex - 1);
            }

            if (pivotIndex + 1 < high) {
                stack.push(pivotIndex + 1);
                stack.push(high);
            }
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;

        for (int j = low; j < high; j++) {
            if (arr[j] <= pivot) {
                i++;
                swap(arr, i, j);
            }
        }

        swap(arr, i + 1, high);
        return i + 1;
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        quickSort(arr);
        System.out.println("Sorted array:");
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

在这个实现中，我们使用了一个双向队列ArrayDeque作为栈，用于存储待处理的子数组的边界。quickSort函数初始化栈，然后在一个循环中不断弹出栈顶的高边界和低边界，进行分区操作，并根据分区结果更新栈的内容，直到栈为空为止。

这种非递归的方法可以有效地减少内存栈的使用，避免了在递归深度过深时可能出现的栈溢出问题，同时也能保持快速排序的高效性能。在实际应用中，你可以根据具体需求调整分区策略、基准值的选择方法等，以进一步优化排序过程。

hummhumm
关注
数据结构课件（从第1节到21节ppt课件哦）
04-01
8. **排序与查找**：第18-20节，包括各种排序算法（冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等）和查找算法（顺序查找、二分查找、哈希查找等）。这些算法是编程的基础，直接影响程序效率。 9. *...
Java之快速排序详解&三数取中优化
m0_52822318的博客
08-04 243
快速排序算法详解，包括Java语言具体实现、执行过程分析、时间复杂度分析、三数取中优化方案
快速排序法 java实现 三种方法实现
学习学习再学习
05-18 7512
快速排序法 (1)定义 快速排序使用分治的思想，通过一趟排序将待排序列分割成两部分，其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序，以达到整个序列有序的目的。 (2)快速排序的三个步骤 选择基准：在待排序列中，按照某种方式挑出一个元素，作为 "基准"（pivot） 分割操作：以该基准在序列中的实际位置，把序列分成两个子序列。此时，在基准左边的元素都比
Java 快速排序
m0_74294415的博客
04-16 1184
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法。
南昌大学～学年第二学期数据结构期末考试标准答案C.doc
12-21
本篇内容涉及的是南昌大学某学年第二学期数据结构课程的期末考试标准答案，主要包括填空题和判断题，涵盖了数据结构的基础概念、操作以及算法分析。 1. 在链表操作中，插入节点是一项基本操作。题目描述了在一个...
数据结构第2版-书中算法（C语言版）
05-12
《数据结构第2版-书中算法（C语言版）》是一本针对该主题的重要教材，其主要内容包括C语言实现的数据结构相关算法。以下是对该书中的关键知识点的详尽解析： 一、线性数据结构 1. 数组：数组是最基本的数据结构，它...
近20年真题811数据结构
07-31
近20年的811数据结构真题涵盖了多项关键知识点，包括算法分析、数据结构的实现与操作，以及特定问题的解决策略。 1. **循环嵌套与时间复杂度**： 在第一道题目中，有一个双重循环，外层循环从1到n，内层循环从2i到...
数据结构算法图解-第八章图例.docx
12-09
数据结构和算法是计算机科学的基础，对于理解和解决复杂问题至关重要。在给定的文档中，主要涉及了四种经典的排序...了解并掌握这些排序算法对于理解数据结构和算法，以及在实际编程中选择合适的排序方法都非常重要。
数据结构_图的遍历
2301_79837864的博客
11-17 106
【代码】数据结构_图的遍历。
【数据结构和算法】-布隆过滤器
前鼻音的博客
11-14 798
布隆过滤器的思想就是，1个哈希容易冲突，那就上多个哈希函数，即使1个位上冲突了，其他位冲突的概率也非常小。注意map是key、value形式，我们要检测value存在不存在，是要通过实际判定value的值，如果value本身是个基础类型，那好说。不过，哈希算法会出现哈希冲突，在某些场景下，这是一个比较头疼的问题，就需要算法本身越来越复杂，而且也伴随着存储空间的增加。有些小伙伴又说了，图片也不怕，我有MD5，是，没错，但是要知道MD5的开销是比较大的，这样数据量少还可以，如果是百万级别的数据量呢？
数据结构——红黑树
未知陨落的博客
11-17 803
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或 Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的
数据结构王道P234第二题
qq_63108111的博客
11-17 203
【代码】数据结构王道P234第二题。
优先级队列-PriorityQueue
qq_39203337的博客
11-14 513
无界队列，数据存储于内部数组中，数据采用堆(默认小顶锥)的组织形式。
【数据结构】【线性表】双链表(附C语言源码)
weixin_58498967的博客
11-14 413
在学习单链表指定结点的前插操作和删除操作时，我们遇到一个困难是难以找到其前驱结点，如果需要找到其前驱结点则需要遍历单链表，这样使得其时间复杂度从原本的O(1)，直接变成了O(n)，因此单链表的不可逆性在需要逆向检索时及其不方便，因此我们在构建结点的结构体时，也像记录后继结点的指针next一样，添加一个前驱结点的指针prior，如此可以在任意结点双向遍历检索结点。前者在插入过程中需要关注结点的数据，而后者只需要关注结点的prior和next，因此在后续的代码展示中，均以直接插入结点的方式展示。
Redis 数据结构：List 类型全面解析
喵手的博客
11-14 760
Hello，Redis 爱好者们！Redis 作为一款强大的内存数据库，其丰富的数据结构让它在缓存、消息队列、排行榜等场景中游刃有余。而其中，List类型可以说是最经典、最基础的结构之一。今天，我们就来一次彻底的 List 类型解析，从入门到进阶带你全面掌握它的用法，附上详细案例，保证让你收获满满！在 Redis 中，List是一个简单的字符串列表，按插入顺序排序。它类似于链表，可以进行快速的头尾操作，非常适合用于实现消息队列、任务队列等结构。Redis 的List。
【数据结构】宜宾大学-计院-实验七
2303_80737493的博客
11-14 1100
实验七 二叉树 一、实验目的： 二、实验内容： 三、实验结果： 1,2； 3,4,5; 6. 数组顺序存储的优缺点 二叉链表存储的优缺点
基础排序算法
fengenrong的博客
11-14 994
希尔排序是一种基于插入排序的排序算法，通过对数组进行分组并逐渐减小组间距，改善了插入排序的效率。它通过提前移动远距离的元素，使得数据逐步接近有序，从而减少后续排序的交换次数。比插入排序快：希尔排序相对于直接插入排序有显著的性能提升，尤其是对于较大的数组。原地排序：无需额外的内存空间，空间复杂度为O1O(1)O1。适应性强：可以适应各种规模的数组，尤其在数组规模较大时表现较好。
Java开发人员从了学习ArkTs笔记（三）-数据结构与线程通信全解析
itbird的专栏
11-14 817
本文对arkts，数据结构和线程通信机制有了更深刻的理解。ArkTS不仅继承了TypeScript的语法，还拓展了一系列高效的数据结构，如HashMap、ArrayList、HashSet等，这些数据结构的使用方法与Java非常相似，大大提升了开发效率。此外，ArkTS的线程通信机制也让我印象深刻。通过使用Worker和Emitter，我们可以轻松实现线程间的数据传递和事件处理，这对于构建高性能应用至关重要。
深入理解 C++ 二叉树
最新发布
@Ysjt丨深的博客 喜欢就留下哦
11-18 586
对于第二种情况，将该节点的父节点指向该节点的子节点。对于第三种情况，可以找到该节点的中序后继节点（即该节点右子树中的最小节点），用该后继节点的值替换要删除的节点的值，然后删除后继节点。二叉搜索树是一种特殊的二叉树，对于树中的任意一个节点，其左子树中的所有节点的值都小于该节点的值，其右子树中的所有节点的值都大于该节点的值。完全二叉树是指除了最后一层外，其他每一层的节点数都是满的，并且最后一层的节点从左到右依次排列。完全二叉树是指除了最后一层外，其他每一层的节点数都是满的，并且最后一层的节点从左到右依次排列。
数据结构试题集与解惑：优化算法与数据结构选择
总结起来，这些试题涵盖了数据结构的基本概念、线性结构和非线性结构的区别、数组和链表的使用、树和图的结构特性、查找算法（如二分查找）以及空间复杂度分析，有助于深入理解和掌握数据结构的核心原理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值