zoukankan      html  css  js  c++  java
  • 交换排序(冒泡排序、快速排序)

    交换排序的基本方法:
    两两比较待排序对象的排序码,如果发生逆序,则交换之,直到所有对象都排好序为止。
    交换排序的实施方案:
    1. 冒泡排序
    2. 快速排序

    一、冒泡排序
    1. 算法代码:

    /**
    * 冒泡排序
    **/
    func BubbleSort(data []int) {
    	for i := 0; i < len(data)-1; i++ { //一共冒泡len(data)-1趟
    		exchange := false
    		for j := 0; j < len(data)-i-1; j++ {
    			if data[j] > data[j+1] {
    				data[j], data[j+1] = data[j+1], data[j]
    				exchange = true
    			}
    		}
    		if !exchange { //没有发生移位,说明已排序完成,提前退出冒泡
    			break
    		}
    	}
    }
    

    2. 空间复杂度:O(1)
    3. 时间复杂度:O(n*n)
    4. 稳定性:稳定

    二、快速排序
    1. 算法描述:
    任取待排序对象中某个对象作为基准,按照该对象的排序码大小,将所有对象划分为左右两个子序列,左序列所有对象排序码都小于或等于基准对象的排序码,右序列所有对象的排序码都大于基准对象的排序码,基准对象则放置在这两个序列中间,然后分别对这两个子序列重复实施上述方法,直至所有对象都排在相应位置上为止。
    2. 算法代码:

    /**
    * 快速排序
    **/
    func QuickSort(slice []int, start, end int) {
    	if start >= end {
    		return
    	}
    	i, j := start, end
    	val := slice[(i+j)/2]
    	for i <= j {
    		for i <= end && slice[i] < val {
    			i++
    		}
    		for j >= start && slice[j] > val {
    			j--
    		}
    		if i <= j {
    			slice[i], slice[j] = slice[j], slice[i]
    			i++
    			j--
    		}
    	}
    
    	if start < j {
    		QuickSort(slice, start, j)
    	}
    	if end > i {
    		QuickSort(slice, i, end)
    	}
    }
    

    2. 空间复杂度:O(log2n)
    3. 时间复杂度:O(nlog2n)
    就平均计算时间而言,快速排序时所有内排序方法中最好的一个。
    4. 稳定性:不稳定

  • 相关阅读:
    Zookeeper 记录
    Eureka 分析记录
    Hbase 学习记录
    小技巧 Mongodb 动态查询 除去 _class 条件
    科技的继续发展会带给我们什么?
    无限拓展热区域缓存服务方案
    Git 的 4 个阶段的撤销更改
    自动化运维利器 Fabric
    Linux Shell 文本处理工具
    如何在 Linux 中找出 CPU 占用高的进程
  • 原文地址:https://www.cnblogs.com/wujuntian/p/12299545.html
Copyright © 2011-2022 走看看