排序算法之交换(冒泡与快排)

排序算法根据是否需要访问外存,分为内部排序和外部排序。

  • 内部排序是指待排序列完全存放在内存中所进行的排序过程,适合不太大的元素序列。
  • 外部排序是指大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存,需要在内存和外部存储器之间进行多次数据交换,来达到排序整个文件的目的。

一.内部排序

使用内存,分为插入(直接插入排序  希尔排序)、选择(简单选择排序  堆排序)、交换(冒泡排序  快速排序)、归并、基数。

5.冒泡排序

效率很低,实现简单

  • 基本思想:对相邻的元素进行两两比较,顺序相反则进行交换。每一趟排序都会将最小或最大的元素放置待排数组的末尾,最终达到完全有序。

待排序列:3、1、4、2
第一趟排序结果:1、3、2、4
第二趟排序结果:1、2、3、4
第三趟排序结果:1、2、3、4

最终排序结果为:1、2、3、4

  • 代码实现(Java) 
    public static void bubbleSort(int[] arr){
        for (int i=arr.length-1;i>0; i--){
            //设定一个标记,作为没有发生数据交换的标志。若此次循环没有进行交换,表示排序完成                
            boolean flag = true;
            //已经有i个元素排好序
            for (int j=0;j<i; j++){
                if(arr[j] > arr[j+1]){
                    swap(arr,j,j+1);
                    flag = false;
                }
            }
            System.out.println("第"+(arr.length-i)+"趟排序结果:");
            display(arr);
            if(flag){
                break;
            }
        }
    }
	public static void swap(int[] arr, int a,int b) {
		if(arr[a]>arr[b]) {
			arr[a]=arr[a]+arr[b];
			arr[b]=arr[a]-arr[b];
			arr[a]=arr[a]-arr[b];
		}
	}
	public static void display(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			System.out.print(arr[i]+"  ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int arr[]= {9,3,1,4,2,7,8,6,5};
		bubbleSort(arr);
		System.out.println("最终排序结果为:");
		display(arr);
	}
  • 算法分析

冒泡排序的时间复杂度为O(n^2)。最坏情况,逆序O(n*(n-1)/2);最好情况,顺序O(n-1)。

6.快速排序

基于分治算法

  • 基本思想:
    选择一个基准元素,通常选择第一个元素或最后一个元素。
    通过一趟排序将待排元素分为两部分,一部分元素小于基准元素,另一部分元素大于基准元素。
    此时,基准元素在处于最终序列的正确位置。分别对这两部分使用同样的方法进行排序,直至整个序列有序。
  • 代码实现(Java):
public class QuickSort {
	public static void quickSort(int[] arr) {
		if(arr.length<0 || arr==null) {
			return;
		}
	    quickSort(arr,0,arr.length-1);
	}
	public static void quickSort(int[] arr, int low, int high) {
		if(low>=high) {
			return;
		}else {
			int flag=arr[low];
			int partition=partition(arr,low,high,flag);
			display(arr);
			quickSort(arr,low,partition-1);
			quickSort(arr,partition+1,high);
		}
	}
	public static int partition(int[] arr,int low,int high,int flag) {
		while(low<high) {
			while(low<high && arr[high]>=flag) {
				high--;
			}
			swap(arr,low,high);
			while(low<high && arr[low]<=flag) {
				low++;
			}
			swap(arr,low,high);
		}
		arr[low]=flag;
		return low;
	}
	public static void swap(int[] arr, int a,int b) {
			arr[a]=arr[a]+arr[b];
			arr[b]=arr[a]-arr[b];
			arr[a]=arr[a]-arr[b];
	}
	public static void display(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			System.out.print(arr[i]+"  ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int[] arr= {57,68,59,52,72,28,96,33,24,19};
		quickSort(arr);
		System.out.println("最终结果:");
		display(arr);
	}
}
  • 算法分析

时间复杂度为O(n*logn),当数据有小到大或由大到小排列时,快速排序的效率最低,时间复杂度为O(n^2)

选择第一个元素作为基准相对简单,但当其为最大或最小值时,快速排序的效率会降低。这时,采用“三项取中法”来避免最值情况出现。

非递归实现

  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值