函数定义

/*

/*

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

 swift

函数: 达成有些特定职责的代码块, 给代码起3个恰如其分的名目, 称为函数名称;
以往急需实行代码块只须求选拔函数名称调用就能够.

函数: 达成某些特定职分的代码块, 给代码起三个相宜的名号, 称为函数名称;
现在须要进行代码块只须要动用函数名称调用就能够.

importUIKit

 1.打印

print /println

例:print(“hello swift”)   注意:swift能够不用分号


一.常量:程序运转时期不得更改的量  修饰符 let   例:let number = 20

  1. 变量:程序运维期间能够更改的量 修饰符 var  例:var time = 30  time
    = 40 (能够更换)

格式:

格式:

/*

2.标识符

1.由数字 字母 下划线 组成

贰.无法以数字初始

三.不能够与系统第3字重复  `系统主要字`

肆.宏观协助Unicode编码

附加:调用emoj 表情 control + command + 空格


例:let `let` = 十0 (假如和系统命一样的话须要`系统命`)  let 希望
= 20  var  = 40


func 函数名称(参数名:参数类型, 参数名:参数类型,…) -> 函数重返值
{函数完毕部分}

func 函数名称(参数名:参数类型, 参数名:参数类型,…) -> 函数重返值
{函数完成部分}

函数:达成某些特定职责的代码块,给代码起2个老少咸宜的称谓叫作函数名称.现在须要施行代码块只需求利用函数名称调用就能够

三.数据类型

 

 

格式:

1.整形(若未有修饰类型 默许是Int)

1.Swift  Int  

宣称整形的常量可能变量    修饰符 标记符 : 类型 = 发轫值  例:let num
: Int = 20

OC:

OC:

func函数名称(参数名:参数类型,参数名:参数类型…)
->函数重临值{函数实现部分}

贰.浮点型(倘诺没给定类型修饰 暗中认可是Double)

单精度 Float 精确度<=6位    例:let float : Float =
3.1345678987689765

双精度 Doublec 精确度<=15位  例:var double : Double
=9.45687654568762893783937


注意:斯维夫特 中严峻的品种审核,必须确定保证项目相称,本领运算 例:double +
Double(float)

– (void)sayHello

– (void)sayHello

行使func来声称1个函数,使用名字和参数来调用函数。使用->来钦定函数再次来到值。

三.字符和字符串(String)

例:let char : Character = “a”

var dashabi : String = “dashabi”

var 修脚 : NSString = “修脚”


字符串的拼接:dashabi + “12345678九”    (dashabi +=
“1234567捌odasfdf”)

不等品种的字符串拼接,需zhuan    as 强转修饰符

dashabi + (修脚 as String)

字符串调用方法用点调用(斯威夫特 中从未[])

var saodong = “saodong”

saodong.uppercaseString //大写      saodong.lowercaseString //小写

字符串长度

saodong.characters.count

别的品种转字符串

一.插入语法  例:let num : Int = 20         “\(num)” 


二.String() Xcode 陆.四不只怕利用

String(num)     

saodong == dashabi

Bool类型

var xiaosaodong : Bool = true

可选类型 ?    (!强制解析,把不自然的值明确)

var saoder : String? = “11”

print(sadder)    !强制解析,把不自然的值断定


例:saoder! + “aaa”

元组类型  (元组有四个参数)

例1:var zhaodeyu = (“zhaodeyu”, 100, “性别不详”)

zhaodeyu.0

zhaodeyu.1

zhaodeyu.2


例2: var xiaozhao = (name : “xiaozhao”, age : 100, sex : “nv”)

xiaozhao.name  (xiaozhao.0)

xiaozhao.age  (xiaozhao.1)

xiaozhao.sex  (xiaozhao.2)


例3: let (name, age, sex) = xiaozhao

name

age

sex


{

{

*/

4.数组类型

数组初叶化:  Array恐怕 [SomeType]

一>空数组的开头化    例:let array : [Int] = []

应用开头化格局      let arr = [Int]()

采取初叶化      let ar = Array()


2> 非空数组  直接采纳非空的数组    例:let 数组 : [Int] = [2, 1,
3, 4, 5, 6, 8]

使用起初化方法

let myArray = [Int](count: 5, repeatedValue: 1)

var myArr = Array(arrayLiteral: 1, 2, 3, 4, 5)


认清是还是不是位空  :myArr.isEmpty      arr.isEmpty

数组添日元素

myArr.append(11)     

myArr += [22]

插入成分

myArr.insert(99, atIndex: 0)

取值

myArr[0]

修改

myArr[1] = 30

替换[0,3] 0到3

myArr[0…3] = [1, 2, 3, 4]

删除

myArr.removeLast()

myArr.removeAtIndex(0)

myArr.removeAll()

NSLog(@”hello”);

NSLog(@”hello”);

//无参无重回值

5.字典

字典的开首化方式

let dic = Dictionary()

var dictionary = [“name” : “修  睿”


字面量判定key值是不是留存,假设存在,修改value不然加多

dictionary[“sex”] = “女”

dictionary.updateValue(“男”, forKey: “sex”)

dictionary

字典的去除

dictionary.removeValueForKey(“name”)

字典通过键值下表移除Key-Value

let index = dictionary.indexForKey(“sex”)

dictionary.removeAtIndex(index!)

dictionary


}

}

funcsay() ->Void

Swift的逻辑决断

if…else  

例:if 1 > 2 {

} else {

}

Switch…case

注意:一.不用写break,对应当一个falthrough

        二.填入的按钮,不再知识整形的表明式能够是字符串

        三.case的原则能够不是永远的值,是个区间

let abc = 30

switch abc {

  case 10:

        print(“10”)

case 30:

        print(“30”)


var nameArr = [“zhangsan”, “lisi”]

  switch nameArr[0]  {

          case “zhangsan”:

                  print(“zhangsan”)


[0, 3] 0 <= x <= 3      0…3

[0, 4) 0 <= y < 4        0..<4

例:let score = 90 {

            case 0..<60:

                   print(“不及格”)

            case 80..<100:

                   print(“优秀”) 


– (void)sayWithName:(NSString *)name

– (void)sayWithName:(NSString *)name

{

6.循环

while

var i = 10

while i < 100 {

i++

}

do..while  (repeat..while)

repeat {

i++

} while i < 200

for循环

for var i = 0; i < 100; i++ {

i++

}


{

{

print(“hello”)

7.函数

func 函数名 (参数列表)->再次来到值{ 函数体 }

func printHello() {

print(“Hello, Swift!”)

}

printHello()


有参单重临  inout修改

func sumNumber(inout a: Int, b: Int) ->Int {

return a + b

}

var a = 100

sumNumber(&a, b: 20)


有参无重返

func printName(name: String) {

print(“名字是” + name)

}

printName(“小明”)


无参单重回

func nameString() ->String {

return “席主席”

}

nameString()


有参数多重临

func returnStudent(name: String, age: Int, sex: String) ->(name:
String, age: Int, sex: String) {

return (name, age, sex)

}

var (name1, age1, sex1) = returnStudent(“小赵”, age: 12, sex: “男”)


无参数多重返

func moreString() ->(nameMore: String, age: Int) {

return (“赵永洪”, 22)

}

moreString()


/******冒泡排序*******/

var maopaoArr = [1, 2, 4, 2, 6, 0, 7]

for var i = 0; i < maopaoArr.count; i++ {

        for var j = 0;  j < maopaoArr.count – 1; j++ {

                 if maopaoArr[j] > maopaoArr[j + 1] {

                        var temp:Int

                        temp = maopaoArr[j]

                        maopaoArr[j] = maopaoArr[j + 1]

                       maopaoArr[j + 1] = temp

         }

     }

}

print(maopaoArr)

闭包  匿名函数      格式:{(参数列表) ->再次来到值类型 in 代码段}

let block = {(str : String) ->String in

       return str

}

block(“a” + “b”)




NSLog(@”hello %@”, name);

NSLog(@”hello %@”, name);

}

八. 类和结构体

一样点: 一.都包罗属性和章程,
swift的结构体与OC的结构体都有不小的不同

              二.都蕴涵构造器方法

差别点:  1.类能够被持续,结构体不能够  

               2.类包罗析构器,结构体未有

1.类

特点:

相互不能够同时设有

wiliest  和  didset

壹.属性能够一直赋初值

二.属性可以不明确

例:var name : String?

       var age : Int?

器方法  约等于在此之前的 alloc init

例:init(name : String, age : Int) {

           self.name = name

           self.age = age

}

func printAge() {

            print(self.age!)

}

析构器

deinit {

        // 释放财富

       //监听 代理

}

let person = Person (name: “zhao”, age: 56)

person.printAge()


2 结构体 

例:struct Car {

               var carName : String?

               var carNumber : Int?

               init(carName : String, carNumber : Int) {

                          self.carName = carName

                          self.carNumber = carNumber

   }

   func printName() {

   print(self.carName!)

}

}

总结

Class Student : Person {

       var sex : String?

//重写父类的开端化方法

       override init(name : String, age : Int) {

//super的机要字

                    super.init(name : name, age : age) 

       }

        init(studentName : String, age : Int,  studentNumber : Int,
studentSex : String) {

                   super.init(name : StudentName, age : age)

                   self.sex = studentSex

      }

     //class修饰符的章程,正是父类的章程 

        class fun printName(name : String) {

                  print(name)

      }

}

Student.printName(“字符串”)




协议,protocol 协议名 {}

注意壹.假设类有承继关系,在所承接的类前面以逗号分隔去签协议

          二.若果类未有继续关系,在冒号之后签订协议

例1:

protocol personDelegate {

      fun change() ->String

}

例2:

class teacher : Person,  PersonDelegate {

        func change() ->String {

                  return “name”

        }

}

}

}

funcsay一()//假设未有再次来到值可以不写

– (void)sayWithName:(NSString *)name age:(NSInteger)age

– (void)sayWithName:(NSString *)name age:(NSInteger)age

{

函数定义。{

{

print(“hello”)

NSLog(@”hello %@ , I’m %tu years old”, name, age);

NSLog(@”hello %@ , I’m %tu years old”, name, age);

}

}

}

say1()

– (NSString *)info

– (NSString *)info

//有参无再次来到值

{

{

funcsayWithName(name:String)

return @”name = lnj, age = 30″;

return @”name = lnj, age = 30″;

{

}

}

print(“hello\(name)”)

– (NSString *)infoWithName:(NSString *)name age:(NSInteger)age

– (NSString *)infoWithName:(NSString *)name age:(NSInteger)age

}

{

{

sayWithName(name:”lnj”)

return [NSString stringWithFormat:@”name = %@, age = %tu”, name, age];

return [NSString stringWithFormat:@”name = %@, age = %tu”, name, age];

funcsayWithName1(name:String, age:Int)

}

}

{

 

 

print(“hello\(name) , I’m\(age) years old “)

Person *p = [[Person alloc] init];

Person *p = [[Person alloc] init];

}

[p sayHello];

[p sayHello];

sayWithName1(name:”lnj”, age:30)

[p sayWithName:@”lnj”];

[p sayWithName:@”lnj”];

//无参有重返值

[p sayWithName:@”lnj” age:30];

[p sayWithName:@”lnj” age:30];

funcinfo() ->String

NSLog(@”%@”, [p info]);

NSLog(@”%@”, [p info]);

{

NSLog(@”%@”, [p infoWithName:@”xiaohange” age:23]);

NSLog(@”%@”, [p infoWithName:@”xiaohange” age:23]);

return”name = lnj, age = 30″

*/

*/

}

 

 

print(info())

// 无参无重返值

// 无参无重返值

//有参有重返值

func say()->Void

func say()->Void

funcinfo(name:String, age:Int) ->String

{

{

{

    print(“Hello”)

    print(“Hello”)

return”name =\(name), age =\(age)”

}

}

}

 

 

print(info(name:”lnj”, age:30))

func say一() // 如若未有重临值可以不写

func say一() // 要是未有再次来到值能够不写

/*

{

{

嵌套函数

    print(“Hi”)

    print(“Hi”)

*/

}

}

funcshowArray(array:[Int])

say()

say()

{

say1()

say1()

fornumberinarray

 

 

{

// 有参无再次来到值

// 有参无再次来到值

print(“嵌套函数\(number), “)

func sayWithName(name:String)

func sayWithName(name:String)

}

{

{

}

    print(“hello \(name)”)

    print(“hello \(name)”)

showArray(array: [1,2,3,4])

}

}

funcswap( a:inoutInt, b:inoutInt)

sayWithName(name: “xiaohange”)

sayWithName(name: “xiaohange”)

{

 

 

lettemp = a

func sayWitchName1(name:String, age:Int) -> Void {

func sayWitchName1(name:String, age:Int) -> Void {

a = b

    print(“hello \(name), I’m \(age) years old”)

    print(“hello \(name), I’m \(age) years old”)

b = temp

}

}

}

sayWitchName1(name: “baobao”, age: 20)

sayWitchName1(name: “baobao”, age: 20)

//冒泡排序算法的周转如下:(从后往前)

 

 

//相比较相邻的因素。假使第一个比第1个大,就调换他们八个。

// 无参有重回值

// 无参有重返值

//对每一对周围元素作同样的干活,从初阶首先对到结尾的最终一对。在那或多或少,最终的要素应该会是最大的数。

func info() -> String

func info() -> String

//针对富有的成分重复以上的步子,除了最终叁个。

{

{

//持续每回对越来越少的因素重复上边的步子,直到未有其它一对数字须求比较。

    return “name = hjq, age = 28”

    return “name = hjq, age = 28”

funcbubbleSort(array:inout[Int])

}

}

{

print(info())

print(info())

print(“调用方法开头”)

 

 

letcount = array.count;

// 有参有重返值

// 有参有重回值

foriin1..< count

func info(name:String, age:Int) -> String

func info(name:String, age:Int) -> String

{

{

{

print(“i的值为\(i)”)

    return “name = \(name), age = \(age)”

    return “name = \(name), age = \(age)”

forjin0..< (count – i)

}

}

{

print(info(name: “HaRi”, age: 26))

print(info(name: “HaRi”, age: 26))

print(“j为==================================\(j)”)

 

 

ifarray[j] > array[j +1]

/********** 嵌套函数 **********/

/********** 嵌套函数 **********/

{

func showArray(array:[Int])

func showArray(array:[Int])

swap(a: &array[j], b: &array[j +1])

{

{

}

    for number in array {

    for number in array {

print(“在内层循环的结果\(array)”)

        print(“\(number)”)

        print(“\(number)”)

}

    }

    }

}

}

}

}

showArray(array: [1,2,3,4,5])

showArray(array: [1,2,3,4,5])

vararr:Array = [31,13,52,84,5]

 

 

bubbleSort(array: &arr)

/* 苹果自带api

/* 苹果自带api

//var strArray = [“Tom”,”Sam”,”Alick”,”Meria”]

func swap( a:inout Int, b:inout Int) // 2.0 是 func swaping(inout a:Int,
inout b:Int) 废弃

func swap( a:inout Int, b:inout Int) // 2.0 是 func swaping(inout a:Int,
inout b:Int) 废弃

//strArray.sort()

{

{

//———————函数参数

    let temp = a

    let temp = a

/*

    a = b

    a = b

个中等高校函授数:默许意况下的参数都是中间参数

    b = temp

    b = temp

外部参数只好外部用,函数内部不可能运用,函数内部只好选用其中参数

}

}

*/

*/

*/

funcgetvalue(a:Double, divisor b:Double) ->Double{

 

 

returna / b

/*********** 冒泡排序,插入排序,采取排序,火速排序
***********/

/*********** 冒泡排序,插入排序,选拔排序,快速排序
***********/

}

// 冒泡排序

// 冒泡排序

print(getvalue(a:15, divisor:3.5))

func bubbleSort(array:inout [Int])

func bubbleSort(array:inout [Int])

/*

{

{

私下认可参数:

    func swap( a:inout Int, b:inout Int)

    func swap( a:inout Int, b:inout Int)

能够在概念函数的时候给某些参数赋值,当外部调用未有传递该参数时会自动使用暗许值

    {

    {

*/

        let temp = a

        let temp = a

funcjoinString(s1:String,toString s2:String, jioner s3:String=”❤️”)
->String

        a = b

        a = b

{

        b = temp

        b = temp

returns1+s3+s2;

    }

    }

}

    for _ in 0..<array.count {  // 用不到的参数能够用 _ 代替

    for _ in 0..<array.count {  // 用不到的参数能够用 _ 代替

print(joinString(s1:”hi”, toString:” beauty”))

        for j in 0..<(array.count-1) {

        for j in 0..<(array.count-1) {

//纵然钦赐了默许参数,不过却从未证明外部参数时,系统会自行把内部参数名称既作为内部参数也当作外部参数名称,并且在调用时假如急需修改私下认可参数的值必须写上外国国语高校部参数名称

            if array[j] > array[j + 1] {

            if array[j] > array[j + 1] {

funcjoinStringwithTitle(s1:String,toString s2:String,
jioner:String=”❤️”) ->String

//                let temp = array[j]

//                let temp = array[j]

{

//                array[j] = array[j + 1]

//                array[j] = array[j + 1]

returns1+jioner+s2;

//                array[j + 1] = temp

//                array[j + 1] = temp

}

                swap(a: &array[j], b: &array[j + 1])

                swap(a: &array[j], b: &array[j + 1])

print(joinStringwithTitle(s1:”hi”, toString:”beauty”, jioner:”🐔”))

                

                

//私下认可意况下Swift中全体函数的参数都是常量参数,如需修改为变量需在函数内再度赋值

            }

            }

funcswapvalue(a:Int, b:Int)

        }

        }

{

    }

    }

varb = b

    

    

vara = a

}

}

print(“交换前a =\(a) b =\(b)”)

var arr:Array<Int> = [10, 23, 22, 40, 6]

var arr:Array<Int> = [10, 23, 22, 40, 6]

lettemp = a;

bubbleSort(array: &arr)

bubbleSort(array: &arr)

a = b;

showArray(array: arr)

showArray(array: arr)

b = temp;

 

 

print(“交换后a =\(a) b =\(b)”)

// 插入排序

// 插入排序

}

var arr1:Array<Int> = [10, 34, 23, 9, 12]

var arr1:Array<Int> = [10, 34, 23, 9, 12]

swapvalue(a:10, b:20)

for i in (0..<arr1.count) {

for i in (0..<arr1.count) {

//inout参数,假设想在函数中期维修改外界流传的参数,能够在参数的数据类型增添关键字inout,那回会传递参数自身而不是参数的值

    

    

varx1 =10;

    var key = arr1[i]

    var key = arr1[i]

vary1 =20;

    

    

funcswap3(ax:inoutInt, bx:inoutInt)

    var j = i – 1

    var j = i – 1

{

    

    

lettemp = ax;

    while j >= 0 {

    while j >= 0 {

ax = bx;

        

        

bx = temp;

        if arr1[j] > key {

        if arr1[j] > key {

print(“交换后a =\(x1) b =\(y1)”)

            arr1[j + 1] = arr1[j]

            arr1[j + 1] = arr1[j]

}

            arr1[j] = key

            arr1[j] = key

print(“交换前a =\(x1) b =\(y1)”)

        }

        }

swap3(ax: &x1, bx: &y1)

        j -= 1

        j -= 1

//print(“交换后a = \(x1) b = \(y1)”)

    }

    }

/*

}

}

swift有三种参数字传送递情势

print(arr1)

print(arr1)

1.值传递

 

 

值传递的是参数的三个别本,那样在调用参数的长河中不会潜移默化原有数据。

// 选择排序

// 接纳排序

二.指针传递

var arr2:Array<Int> = [100, 304, 203, 90, 102]

var arr2:Array<Int> = [100, 304, 203, 90, 102]

指南针传递把参数自己引用(内部存款和储蓄器地址)传递过去,在调用的历程会影响原本数据。

for i in (0..<arr2.count – 1) {

for i in (0..<arr2.count – 1) {

在Swift众很多据类型中,唯有class是指针传递,其他的如Int,Float,Bool,Character,Array,Set,enum,struct全都以值传递.

    

    

让值传递以指针形式传递

    //    print(i)

    //    print(i)

偶尔大家必要通过一个函数退换函数外面变量的值(将1个值类型参数以引用格局传送),那时,Swift提供的inout关键字就能够兑现

    

    

即:证明函数时,在参数前边用inout修饰,函数内部贯彻转移外部参数字传送入参数时(调用函数时),在变量名字前边用&符号修饰表示,注脚那一个变量在参数内部是足以被改变的(可将转移传递到原始数据)

    var index = i

    var index = i

*/

    

    

varvalue =50

    for j in (i..<arr2.count) {

    for j in (i..<arr2.count) {

funcincrement(value:inoutInt, length:Int) {

        

        

value += length

        if arr2[index] > arr2[j] {

        if arr2[index] > arr2[j] {

}

            

            

increment(value: &value, length:20)

            index = j

            index = j

print(value)

        }

        }

/*注意

    }

    }

inout修饰的参数是无法有暗中认可值的,有限量的参数集合也不能够被修饰;

    let tmp = arr2[i]

    let tmp = arr2[i]

四个参数一旦被inout修饰,就不能够再被var和let修饰了。

    arr2[i] = arr2[index]

    arr2[i] = arr2[index]

*/

    arr2[index] = tmp

    arr2[index] = tmp

/*

    

    

变参函数

}

}

借使函数的参数个数不明确,那么只好写多少个法子大概用将函数参数改为集聚

print(arr2)

print(arr2)

变参只可以放到参数列表的结尾一人,变参必须钦命数据类型,变参只可以是同类别型的数量

 

 

*/

 

 

funcadd(other:Int, nums:Int…) ->Int

/***********澳门葡京备用网址, 三种高效排序: ***********/

/*********** 二种高效排序: ***********/

{

 

 

varsum =0;

// quick sort1

// quick sort1

fornuminnums

var array = [66,13,51,76,81,26,57,69,23]

var array = [66,13,51,76,81,26,57,69,23]

{

func partition( list:inout [Int],left:Int,right:Int) -> Int{

func partition( list:inout [Int],left:Int,right:Int) -> Int{

sum += num

    

    

}

    var pivot_index = left

    var pivot_index = left

returnsum

    let piovt = list[left]

    let piovt = list[left]

}

    

    

print(add(other:9玖,
nums:1,二,三))//会将9玖传递给第六个参数,后边的传递给nums

    for i in (left … right) {

    for i in (left … right) {

varnumbers = [20,19,7,12]

        

        

//函数实际上是壹种尤其的闭包,你可以接纳{}来创设二个匿名闭包。使用in将参数和再次来到值类型申明与闭包函数体举办分离。

        print(i)

        print(i)

numbers.map({

        

        

(number:Int) ->Intin

        if list[i] < piovt {

        if list[i] < piovt {

letresult =3* number

            

            

returnresult

            pivot_index += 1

            pivot_index += 1

})

            

            

//你能够透过参数地方而不是参数名字来引用参数——那几个点子在尤其短的闭包中卓越管用。当二个闭包作为最后3个参数传给三个函数的时候,它可以直接跟在括号后边。

            if pivot_index != i {

            if pivot_index != i {

print(numbers.map({ numberin3* number }))

                

                

//map怎么利用

                swap(&list[pivot_index], &list[i])

                swap(&list[pivot_index], &list[i])

letmapnumbers = [1,2,3,4]

                

                

letresult =mapnumbers.map{ $0 +2}

            }

            }

print(result)// [3,4,5,6]

        }

        }

//map方法接受3个闭包作为参数,然后它会遍历整个numbers数组,并对数组中种种要素推行闭包中定义的操作。也正是对数组中的全数因素做了三个映射。比如我们那一个例子里面包车型客车闭包是讲全部因素都加2。这样它发出的结果数据便是[3,4,5,6]

     }

     }

letstringResult =mapnumbers.map{“No.\($0)”}

    swap(&list[left], &list[pivot_index])

    swap(&list[left], &list[pivot_index])

print(stringResult)

    return pivot_index

    return pivot_index

// [“No. 1”, “No. 2”, “No. 3”, “No. 4”]

}

}

//这一次我们在闭包装把传递进入的数字拼接到一个字符串中,然后重返三个组数,那些数组中包罗的数据类型,正是我们拼凑好的字符串。

func quickSortArray( list:inout [Int],left:Int,right:Int) -> Void{

func quickSortArray( list:inout [Int],left:Int,right:Int) -> Void{

/*

    

    

——————————函数类型:

    if left < right {

    if left < right {

恍如于C语言的针对性函数的指针

        

        

类似于OC语言的block

        let pivot_index = partition(list: &list, left: left, right:
right)

        let pivot_index = partition(list: &list, left: left, right:
right)

函数类型是由函数的参数类型和重回值类型组成的

        

        

*/

        quickSortArray(list: &list, left: left, right: pivot_index – 1)

        quickSortArray(list: &list, left: left, right: pivot_index – 1)

//那多少个函数的门类是(Int, Int) -> Int

        quickSortArray(list: &list, left: pivot_index + 1, right:
right)

        quickSortArray(list: &list, left: pivot_index + 1, right:
right)

funcsum(a:Int, b:Int) ->Int

    }

    }

{

}

}

returna + b;

quickSortArray(list: &array, left: 0, right: array.count – 1)

quickSortArray(list: &array, left: 0, right: array.count – 1)

}

showArray(array: array)

showArray(array: array)

//函数类型可以看成函数再次来到值

 

 

funcmax(a:Int, b:Int) ->Int

// quick sort 2

// quick sort 2

{

func quicksort<T: Comparable>(_ a: [T]) -> [T] {

func quicksort<T: Comparable>(_ a: [T]) -> [T] {

returna > b ? a : b

    guard a.count > 1 else { return a }

    guard a.count > 1 else { return a }

}

    let pivot = a[a.count/2]

    let pivot = a[a.count/2]

funcsub(a:Int, b:Int) ->Int

    let less = a.filter { $0 < pivot }

    let less = a.filter { $0 < pivot }

{

    let equal = a.filter { $0 == pivot }

    let equal = a.filter { $0 == pivot }

returna – b;

    let greater = a.filter { $0 > pivot }

    let greater = a.filter { $0 > pivot }

}

    return quicksort(less) + equal + quicksort(greater)

    return quicksort(less) + equal + quicksort(greater)

//能够行使函数类型定义函数变量和常量

}

}

varfuncP:(Int,Int) ->Int=sum

 

 

funcP=sub

let list1 = [ 10, 0, 3, 9, 2, 14, 8, 27, 1, 5, 8, -1, 26 ]

let list1 = [ 10, 0, 3, 9, 2, 14, 8, 27, 1, 5, 8, -1, 26 ]

print(funcP(10,20))

print(quicksort(list1))

print(quicksort(list1))

 

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website