swift版本的快排和归并排序

class SortClass: NSObject {
    func quickSort(inout array:[Int]){
        self.quick(&array, left: 0, right: array.count-1)
    }

    func quickMain(inout array:[Int],var left:Int,var right:Int)->Int{
        var srcLeft=array[left]
        while(left<right){
            while(left<right&&array[right]>=srcLeft){
                right--
            }
            array[left]=array[right]

            while(left<right&&array[left]<=srcLeft){
                left++
            }
            array[right]=array[left]
        }
        array[left]=srcLeft
        return left
    }

    func quick(inout array:[Int],var left:Int,var right:Int){
        if(left<right){
            var middle=self.quickMain(&array, left: left, right: right)
            self.quick(&array, left: left, right: middle-1)
            self.quick(&array, left: middle+1, right: right)
        }
    }

    func mergerSort(inout array:[Int]){
        var tempArray=[Int](count: array.count, repeatedValue: 1)
        self.merger(&array, tempArray: &tempArray, left: 0, right: array.count-1)
    }

    func merger(inout array:[Int],inout tempArray:[Int],var left:Int,var right:Int){
        if(left<right){
            var middle=(left+right)/2
            self.merger(&array, tempArray: &tempArray, left: left, right: middle)
            self.merger(&array, tempArray: &tempArray, left: middle+1, right: right)
            self.mergerMain(&array, tempArray: &tempArray, leftStart: left, leftEnd: middle, rightStart: middle+1, rightEnd: right)
        }
    }

    func mergerMain(inout array:[Int],inout tempArray:[Int],var leftStart:Int,var leftEnd:Int,var rightStart:Int,var rightEnd:Int){
        var index=leftStart
        var recoderLeftStart=leftStart;
        while(leftStart<=leftEnd&&rightStart<=rightEnd){
            if(array[leftStart]<=array[rightStart]){
                tempArray[index++]=array[leftStart++]
            }else{
                tempArray[index++]=array[rightStart++]
            }
        }

        while(leftStart<=leftEnd){
            tempArray[index++]=array[leftStart++]
        }

        while(rightStart<=rightEnd){
            tempArray[index++]=array[rightStart++]
        }

        for(var i=recoderLeftStart;i<=rightEnd;i++){
            array[i]=tempArray[i]
        }
    }
}

学习了swift总体感觉不错.吐嘈两点,1编码的时候智能提示不友好,2希望后续版本能有方法访问权限修饰关键字添加。

时间: 2024-10-07 06:18:32

swift版本的快排和归并排序的相关文章

快排、归并排序(分治)、堆排序

一.快速排序 1)算法简介 快速排序是由C. A. R. Hoare所发展的一种排序算法.其基本思想是基本思想是,通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序. 2)算法描述 快速排序使用分治法来把一个串(list)分为两个子串行(sub-lists). 步骤为: 1.从数列中挑出一个元素,称为 "基准"(pivot), 2.重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准

快排和归并分治总结

快排和归并排序都运用了分治的思想,所以在我看来这两种排序方法都有自己的相似性. 快排 在快排中,首先运用的是分割的方式,选取pivot,将比pivot小的元素放在pivot前面.将比pivot大的元素放在pivot后面. quickSort(arr[],low,high) { if(low<high) { pi = partition(arr,low,high); quickSort(arr,low,pi-1); quickSort(arr,pi+1,high); } } 接下来是实现这个方法的

堆排 归并排序 快排

堆排序的思想 利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性,使得每次从无序中选择最大记录(最小记录)变得简单. 其基本思想为(大顶堆): 1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆,此堆为初始的无序区: 2)将堆顶元素R[1]与最后一个元素R[n]交换,此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n]; 3)由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,

Java排序算法分析与实现:快排、冒泡排序、选择排序、插入排序、归并排序(二)

一.概述: 上篇博客介绍了常见简单算法:冒泡排序.选择排序和插入排序.本文介绍高级排序算法:快速排序和归并排序.在开始介绍算法之前,首先介绍高级算法所需要的基础知识:划分.递归,并顺带介绍二分查找算法. 二.划分: 划分是快速排序的前提,即把数据分为两组,大于特定值的数据在一组,小于特定值的数据在另一组.快速排序即是由划分和递归操作来完成的. (1)原理: 定义一个阈值,分别从最左面和最右面向中间遍历元素,左面找到一个大于阈值的数据便停止,右边找到一个小于阈值的数据便停止,如果此时左右两边都还没

快排,堆排与归并排序

快排: Parition函数用于进行一次快排,本次快排将某个元素放在它应该呆在的位置pos.pos左侧全比它小,pos右侧全比它大. Parition中,设置low指针与high指针,以待排元素为标杆,判断high指向元素是否大于待排元素,若小于则与low指向的元素交换,并切换到low指针.low指针此时指向刚交换过来的元素,其一定小于待排元素,然后low自加直到low指向的元素大于待排元素,此时再与high指向的元素交换,high指向的元素为之前一次low - high交换前low指向的元素:

排序---内部排序算法(快排、希尔排序、归并排序、基数排序、冒泡、选择排序)比较

1.内部排序的复杂度总结 1)时间复杂度 4种排序的平均时间复杂度是O(nlog2n),"快些以nlog2n的速度归队"(快排.希尔排序.归并.堆排序) 最坏情况下,快排的时间复杂度为O(n*n) 2)空间复杂度 O(log2n)快排 O(n)归并 O(rd)基数 其他都是O(1) 3)稳定性 不稳定的:"考研复习痛苦啊,情绪不稳定,快些选一堆好友来聊天吧"(快排.希尔.简单选择排序.堆排序) 其他都是稳定的. 4)一趟排序,保证一个关键字到达最终位置 交换类(起泡

排序(一)归并、快排、优先队列等

排序(一) 初级排序算法 选择排序 思想:首先,找到数组中最小的那个元素.其次,将它和数组的第一个元素交换位置.再次,在剩下的元素中找到最小的元素,将它与数组的第二个元素交换位置.如此往复,直到将整个数组排序. [图例] 图中,x轴方向为数组的索引,y轴方向为待排序元素的值. 选择排序有两个很鲜明的特点: 运行时间和输入无关.为了找出最小的元素而扫描一遍数组并不能为下一遍扫描提供什么信息.这种性质在某些情况下是缺点.(无论数组的初始状态是什么,此算法效率都一样低效) 数据移动是最少的.每次交换都

常见经典排序算法学习总结,附算法原理及实现代码(插入、shell、冒泡、选择、归并、快排等)

博主在学习过程中深感基础的重要,经典排序算法是数据结构与算法学习过程中重要的一环,这里对笔试面试最常涉及到的7种排序算法(包括插入排序.希尔排序.选择排序.冒泡排序.快速排序.堆排序.归并排序)进行了详解.每一种算法都有基本介绍.算法原理分析.算法代码. 转载请注明出处:http://blog.csdn.net/lsh_2013/article/details/47280135 插入排序 1)算法简介 插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法.它的工作原理是通过

Python实现排序(冒泡、快排、归并)

Thomas H.Cormen 的<算法导论>上介绍的几个经典排序算法的Python实现. 1.冒泡排序: 简单的两重循环遍历,使最小(最大)的值不断地往上升(下沉)而实现的排序,算法时间为O(n2). 代码如下: 1 def up_sort(a): 2 # 冒泡排序 3 4 a_length = len(a) 5 while True: 6 i = 0 7 j = 1 8 9 while True: 10 if a[i] > a[j]: 11 a[i], a[j] = a[j], a[