// Playground - noun: a place where people can play

import Cocoa

var nums = Int[]()

for _ in ...

{

    nums.append(random())

}

nums

////冒泡排序

/*

var count = 0;

for(var i = 0 ; i < nums.count-1; i++){

    for(var j = 0; j < nums.count-i-1;j++){

        count++;

        if(nums[j] > nums [j+1]){

            let temp = nums[j];

            nums[j] = nums[j+1];

            nums[j+1] = temp;

        }

    }

}

count

*/

////冒泡排序 优化版

/*

var count = 0;

var flag = true;

for (var i = 0; i < nums.count - 1 && flag ; i++) {//外层训话

    flag = false;

    for (var j = 0; j < nums.count - i - 1; j++) {//内层循环

        count++;

        if (nums[j] > nums[j + 1]) {//比较大小，大的放后面，小的放前面

            var temp = nums[j];

            nums[j] = nums[j + 1];

            nums[j + 1] = temp;

            flag = true;

        }

    }

}

count

*/

///

//选择排序

/*

for(var i = 0; i < nums.count; i++){//外层扫面控制

    var min = i;//用来记录值最小的下标，默认假设第数组第一个元素为最小。

    for(var j = i; j < nums.count ; j++){

        if(nums[j] < nums[min]){//找出min下标中元素还小的值的下标

            min = j;//保持min始终为最小元素的小标

        }

    }

    if i != min {

        //一趟扫描结束后判断是否找出了最小的值，如果有的话就交换，将这个最小值移动到此次扫描数据的最前端

        var temp = nums[i];

        nums[i] = nums[min];

        nums[min] = temp;

    }

}

nums

*/

//插入排序

/*for (var i = 1; i < nums.count; i++) {// 外层对无序列表的扫描

    if (nums[i] < nums[i - 1]) {

        var temp = nums[i];// 保存该点的值，等会要将该值插入适当位置

        var j = i - 1;

        for (; j >= 0 && temp < nums[j]; j--) {// 往后移 tips此处千万不要 是nums[i] < nums[j]来比较，

            //因为nums[i]这个值在一次移位后就被覆盖了，因此也为什么要用temp来保存这个值的原因

            nums[j + 1] = nums[j];// 数组往后移

        }

        nums[j + 1] = temp;

    }

}

nums

*/

//希尔排序

/*

var increment = nums.count;//增量

while(increment > 1){

    increment = increment/2 ;//增量计算

    //一下基本同插入排序,只是直接插入排序我们比较时是增量是1，shell排序设置了一个自己的增量

    for(var i = increment; i<nums.count;i++){

        if(nums[i] < nums[i-increment]){

            var temp = nums[i];

            var j = i - increment;

            for(;j >= 0 && temp < nums[j] ; j -= increment ){

                nums[j+increment] = nums[j];

            }

            nums[j+increment] = temp

        }

    }

}

nums

*/

/*

//堆排序

func  HeapAdjust(nums : Int[],node : Int,length : Int)

{

    if ((node*2+1) <= length-1) {// 保证该节点为非叶子节点，因为叶子节点就没意义了

        var child = node * 2 + 1;//字节点坐标，主要是交换完后需要以该child为节点判断以及调整大根堆

        if (child + 1 <= length-1) {//如果有有右子树

            if (nums[child + 1] > nums[child]) {

                child++;//判断后如果右子树大于左子树，child++，即等会要操作的是左子树节点

            }

        }

        if(nums[node] < nums[child]){//大的子树与node比较

            //交换

            var temp = nums[node];

            nums[node] = nums[child];

            nums[child] = temp;

            //再次重构

            HeapAdjust(nums, child, length);

        }

    }

}

var n = nums.count;

//step1：序列构建成大根堆

for(var i = (n-1)/2 ;i >= 0; i--){

    //即对每个节点和其子节点的大根堆构造

    HeapAdjust(nums, i, n);

}

nums

//step2：遍历最大元素移动到末端

for(var x = (n-1) ; x > 0 ; x--){

    var temp = nums[x];

    nums[x] = nums[0];

    nums[0] = temp;

    //step3：重构

    HeapAdjust(nums, 0, x);

}

nums

*/

//归并排序

/*

func Merging(nums : Int[] , head: Int , mid : Int , tail : Int ) {

    var mius = tail-head+1

    var temp : Int[] = Int[]() //   tail-head+1 // 申请额外空间

    for _ in 1...mius

    {

        temp.append(0)

    }

    var low = head;

    var lowTow = head;

    var lowTowFine = head;

    var high = tail;

    var j = mid + 1;

    var p = 0;

    mius

    //两个子序列都非空

    while (head <= mid && j <= tail) {

        if (nums[head] > nums[j]) {

            temp[p++] = nums[j++];

        } else {

            temp[p++] = nums[lowTow++];

        }

    }

    //第一个子序列非空，将其中剩余的元素复制到temp中

    while (head <= mid) {//

        temp[p++] = nums[lowTowFine++];

    }

    //第二个子序列非空，将其中剩余的元素复制到temp中

    while (j <= tail) {//

        temp[p++] = nums[j++];

    }

    //将缓存中的刷到归并序列中

    for(var q = 0 , t = low ; t <= high ; q++ , t++){

        nums[t]=temp[q];//归并完成后将结果复制回R[low..high]

    } //Merge

}

var length = nums.count;

for (var n = 1; n < nums.count; n *= 2) {// 做logn 趟归并

    var i:Int;

    for (i = 0; i + 2 * n - 1 <= length-1; i = i + 2 * n) {

        Merging(nums, i, i + n - 1, i + 2 * n - 1);// 归并长度为length的两个相邻子文件

    }

    if (i + n - 1 < nums.count-1) // 尚有两个子文件，其中后一个长度小于length

    {

        Merging(nums, i, i + n - 1, nums.count-1); // 归并最后两个子文件

    }

}

nums

*/

/*

//快速排序

func partition( nums : Int[] , lower : Int ,higher: Int ) -> Int {

    var key = nums[lower];

    var numsTwo : Int[] = nums

//    var temp : Int[];

    var high:Int = higher

    var low:Int = lower

    while low < high {

        while (low < high && numsTwo[high] >= key)

        {

            high--

        }

        if (low < high) {

            var temp = numsTwo[low];

            numsTwo[low] = numsTwo[high];

            numsTwo[high] = temp;

        }

        while (low < high && numsTwo[low] <= key) {

            low++;

        }

        if (low < high) {

            var  temp = numsTwo[low];

            numsTwo[low] = numsTwo[high];

            numsTwo[high] = temp;

        }

    }

    return low;

}

func quickSort(nums : Int[] , low: Int , high: Int ) {

    var mid:Int;

    if (low < high) {

        mid = partition(nums, low, high);

        quickSort(nums, low, mid - 1);

        quickSort(nums, mid + 1, high);

    }

}

quickSort(nums,0,0)

*/