ios Swift 算法

// 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)
*/

基本集成通常基本算法:

大致集成:

冒泡排序 -> 选择排序->插入排序

希尔排序->堆排序->归并排序-> 快速排序

这其中每种排序都有优化排序法,需要多练习、琢磨

上一篇:iOS 新特性关键字


下一篇:在越狱的iPhone/iPad上安装自开发环境