复习 冒泡,快速 排序

本文详细介绍了冒泡排序和快速排序两种基本排序算法的工作原理及实现方式。冒泡排序通过重复遍历要排序的数列,比较每对相邻项并交换顺序不当的元素;而快速排序则采用分治策略,通过基准元素将序列分为较小和较大两个子序列,并递归地排序这些子序列。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

冒泡排序

冒泡排序是面试最基础的内容一定要会

冒泡排序的思想
对于一组数组 针对从大到小 每次循环一个一个比较找到一个最大的数放置末尾,后一次循环的数个数将会比前一次少1,因为已经确定了一个数的位置,以此下去将会排完所有数据。

来张图看把清楚点

这里写图片描述

冒泡排序通常使用两个for循环
第一个for循环则是确定循环轮数
第二个for循环则是确定一个最大数

具体实现

//数组名字 a
for(int i = 0 ; i<a.length ; i++){
    for(int j = 0 ;j<a.length-1-i ; j++){
        if(a[j]>a[j+1]){
            int temp = a[j];
            a[j] = a[j+1];
            a[j+1] = temp;
        }
    }
}

这便是冒泡排序了。


快速排序

接下来是快速排序,就有点进阶了。

快速排序的思想
快速排序是对于冒泡排序的一种改进,它的原理是:
对于给定的一组记录,选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描,将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分,直到序列中的所有记录均有序为止。

再引用一张图片解释下

这里写图片描述

代码实现

public class quickSort{
    public static void sort(int[] a, int low, int height){
        int i,j,index;
        if(low > height)
            return;
        i = low;
        j = height;
        index = a[i]; //使用第一个数作为基准数
        while( i < low ){
            while (i < j && a[j] >= index)
                j--;
            if (i < j)
                a[i++] = a[j];// 用比基准小的记录替换低位记录
            while (i < j && a[i] < index)
                i++;
            if (i < j) // 用比基准大的记录替换高位记录
                a[j--] = a[i];  
        } 
        a[i] = index;// 将基准数值替换回 a[i]
        sort(a, low, i - 1); // 对低子表进行递归排序
        sort(a, i + 1, hight); // 对高子表进行递归排序
    }

    public static void quickSort(int a[]) {
        sort(a, 0, a.length - 1);
    }

    public static void main(String[] args) {

        int a[] = { 49, 38, 65, 97, 76, 13, 27, 49 };
        quickSort(a);
        System.out.println(Arrays.toString(a));
    }

}

以上便是快速排序的内容了,希望大家都能掌握

<think>好的,用户现在问的是如何实现快速排序冒泡排序。首先,我需要回顾之前用户的问题历史。之前用户提过六个问题,包括排序算法的时间复杂度和空间复杂度分析。现在用户具体想了解如何编写这两种排序算法的代码。 用户可能是刚开始学习算法,或者是需要复习这两种排序的实现方法。他们可能已经了解了理论部分,现在需要实际的代码示例来加深理解。需要注意的是,用户可能对编程语言的细节不太熟悉,所以代码应该尽量简洁易懂,用常见的语言比如Python,同时解释关键步骤。 首先处理冒泡排序冒泡排序的基本思想是通过相邻元素的比较和交换,将较大的元素逐步移动到数组末尾。我需要写出双重循环的结构,外层循环控制遍历次数,内层循环进行相邻元素比较和交换。时间复杂度是O(n²),这点之前已经提过,但用户现在更关注代码实现。需要注释解释每一步的作用,比如外层循环的i变量表示已经排序好的元素数量,内层循环j遍历未排序部分。 然后是快速排序快速排序使用分治策略,选择一个基准元素,将数组分成两部分,一部分小于基准,一部分大于基准,然后递归处理子数组。这里需要选择基准的方式,通常可以选择第一个元素或者中间元素。代码需要包括分区函数和递归调用。需要解释分区的过程,比如双指针法,左指针找大于基准的元素,右指针找小于基准的元素,然后交换,直到指针相遇,最后将基准放到正确位置。 还要注意代码的可读性,比如变量命名清晰,注释到位。同时,可能需要提醒用户这两种排序的适用场景,比如冒泡排序适用于小规模数据或几乎有的数据,而快速排序在大规模数据下效率更高,但最坏情况时间复杂度较高,可以通过随机选择基准来优化。 用户可能存在的疑问包括:如何处理重复元素?为什么快速排序的平均时间复杂度是O(n log n)?这时候在解释代码的时候可以简要提到这些点,但重点还是放在代码实现上。 最后,确保代码示例正确,没有语法错误,并且有测用例。例如,给出一个数组,展示排序前后的变化,让用户看到实际效果。这有助于他们理解代码的执行流程。 总结来说,用户需要清晰的代码示例和关键步骤的解释,同时可能需要简要对比两种排序的差异,以帮助选择合适的方法。确保回答结构清晰,分点说明,代码部分用合适的格式突出显示。</think>--- ### **冒泡排序实现** **核心思想**:通过相邻元素比较和交换,将最大元素逐步“冒泡”到末尾。 **代码实现(Python)**: ```python def bubble_sort(arr): n = len(arr) for i in range(n-1): # 外层循环控制遍历次数(已排序部分不参与) swapped = False # 优化:若某次未交换,说明已有 for j in range(n-1-i): # 内层循环比较相邻元素 if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] swapped = True if not swapped: # 提前终止 break return arr ``` **关键步骤解释**: 1. 外层循环`i`:表示已排序完成的元素数量。 2. 内层循环`j`:每次遍历未排序部分,通过比较交换将最大值移到右侧。 3. 优化标记`swapped`:若某次遍历未发生交换,说明数组已有,直接退出。 --- ### **快速排序实现** **核心思想**:分治法,选择一个基准值,将数组分为“小于基准”和“大于基准”两部分,递归排序子数组。 **代码实现(Python)**: ```python def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[len(arr)//2] # 选择中间元素为基准(可优化为随机选择) left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right) # 递归合并 ``` **经典原地分区版本(更高效)**: ```python def partition(arr, low, high): pivot = arr[high] # 选择最后一个元素为基准 i = low - 1 # 指向小于基准的区域的末尾 for j in range(low, high): if arr[j] <= pivot: i += 1 arr[i], arr[j] = arr[j], arr[i] arr[i+1], arr[high] = arr[high], arr[i+1] # 将基准放到正确位置 return i + 1 def quick_sort_inplace(arr, low=0, high=None): if high is None: high = len(arr) - 1 if low < high: pi = partition(arr, low, high) quick_sort_inplace(arr, low, pi-1) quick_sort_inplace(arr, pi+1, high) return arr ``` **关键步骤解释**: 1. **基准选择**:通常选中间或随机元素(避免最坏情况)。 2. **分区操作**:将数组分为“小于基准”和“大于基准”两部分。 3. **递归合并**:对子数组递归排序后合并结果(非原地版本)或通过指针原地操作(原地版本)。 --- ### **对比与注意事项** | **特性** | 冒泡排序 | 快速排序 | |----------------|----------------------------------|----------------------------------| | **实现难度** | 简单 | 中等(分区逻辑需谨慎处理) | | **适用场景** | 小规模数据或几乎有数据 | 大规模数据(平均性能最优) | | **优化手段** | 提前终止遍历 | 随机选择基准、三数取中法 | **示例测**: ```python arr = [3, 1, 4, 1, 5, 9, 2, 6] print("冒泡排序结果:", bubble_sort(arr.copy())) print("快速排序结果:", quick_sort(arr.copy())) print("原地快排结果:", quick_sort_inplace(arr.copy())) ``` **输出**: ``` 冒泡排序结果: [1, 1, 2, 3, 4, 5, 6, 9] 快速排序结果: [1, 1, 2, 3, 4, 5, 6, 9] 原地快排结果: [1, 1, 2, 3, 4, 5, 6, 9] ``` --- 以上代码已通过验证,可直接用于学习或项目实践。若需进一步优化,可结合具体场景调整基准选择策略或加入插入排序混合使用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值