已知一个int型数组arraylist[]，写出冒泡排序法
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了已知一个int型数组arraylist[]，写出冒泡排序法相关的知识，希望对你有一定的参考价值。
参考技术A #include "stdio.h"void func(int arrylist[],int len);
int main()
int arrylist[]=5,1,3,8,0,2,4,9,6;
int index;
func(arrylist,9);
for(index=0;index<9;index++)
printf("%d",arrylist[index]);
system("pause");
void func(int arrylist[],int len)
int i,j;
int buf;
for(i=0;i<len-1;i++)
for(j=0;j<len-i-1;j++)
if(arrylist[j]>arrylist[j+1])
buf=arrylist[j];
arrylist[j]=arrylist[j+1];
arrylist[j+1]=buf;
参考技术B 可以直接运行的程序
#include<iostream.h>
void booblesort(int * n)
for (int i=0;i<10;i++)
for (int j=i;j<10;j++)
if(n[j]<n[i])
int tmp=n[i];
n[i]=n[j];
n[j]=tmp;
void main()
int arraylist[10];
for (int i=0;i<10;i++)
arraylist[i]=10-i;
booblesort(arraylist);
for (int j=0;j<10;j++)
cout<<arraylist[j]<<' ';
cout<<endl;
本回答被提问者采纳
Swift之深入解析“泛型”的底层原理
一、泛型简介
① Swift 泛型
- Swift 提供了泛型可以写出灵活且可重用的函数和类型。
- Swift 标准库是通过泛型代码构建出来的，Swift 的数组和字典类型都是泛型集。
- 泛型可以创建一个 Int 数组，也可创建一个 String 数组，或者甚至于可以是任何其他 Swift 的类型数据数组。
- 如下所示，是一个非泛型函数 exchange 用来交换两个 Int 值：
// 定义一个交换两个变量的函数
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}
var numb1 = 100
var numb2 = 200
print("交换前数据: \\(numb1) 和 \\(numb2)")
swapTwoInts(&numb1, &numb2)
print("交换后数据: \\(numb1) 和 \\(numb2)")
- 输出结果为：
交换前数据: 100 和 200
交换后数据: 200 和 100
- 上面的例子只试用与交换整数 Int 类型的变量，如果想要交换两个 String 值或者 Double 值，就得重新写个对应的函数，例如 swapTwoStrings( _ : _ : ) 和 swapTwoDoubles( _ : _ : )，如下所示：
// String 和 Double 值交换函数
func swapTwoStrings(_ a: inout String, _ b: inout String) {
let temporaryA = a
a = b
b = temporaryA
}
func swapTwoDoubles(_ a: inout Double, _ b: inout Double) {
let temporaryA = a
a = b
b = temporaryA
}
- 从以上代码来看，它们功能代码是相同的，只是类型上不一样，这时就可以使用泛型，从而避免重复编写代码。泛型使用了占位类型名（在这里用字母 T 来表示）来代替实际类型名（例如 Int、String 或 Double）。
func swapTwoValues<T>(_ a: inout T, _ b: inout T)
- swapTwoValues 后面跟着占位类型名（T），并用尖括号括起来（），这个尖括号告诉 Swift 那个 T 是 swapTwoValues( _: _: ) 函数定义内的一个占位类型名，因此 Swift 不会去查找名为 T 的实际类型。
- 如下所示，是一个泛型函数 exchange 用来交换两个 Int 和 String 值：
// 定义一个交换两个变量的函数
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
let temporaryA = a
a = b
b = temporaryA
}
var numb1 = 100
var numb2 = 200
print("交换前数据: \\(numb1) 和 \\(numb2)")
swapTwoValues(&numb1, &numb2)
print("交换后数据: \\(numb1) 和 \\(numb2)")
var str1 = "A"
var str2 = "B"
print("交换前数据: \\(str1) 和 \\(str2)")
swapTwoValues(&str1, &str2)
print("交换后数据: \\(str1) 和 \\(str2)")
- 以上程序输出结果为：
交换前数据: 100 和 200
交换后数据: 200 和 100
交换前数据: A 和 B
交换后数据: B 和 A
② 泛型类型
- Swift 允许定义自己的泛型类型，自定义类、结构体和枚举作用于任何类型，如同 Array 和 Dictionary 的用法。
- 如果需要编写一个名为 Stack （栈）的泛型集合类型，栈只允许在集合的末端添加新的元素（称之为入栈），且也只能从末端移除元素（称之为出栈）。如下所示：
- 上图中从左到右解析如下：
-
- 三个值在栈中；
-
- 第四个值被压入到栈的顶部；
-
- 现在有四个值在栈中，最近入栈的那个值在顶部；
-
- 栈中最顶部的那个值被移除，或称之为出栈；
-
- 移除掉一个值后，现在栈又只有三个值。
- 以 Int 型的栈为例，实现是一个非泛型版本的栈：
struct IntStack {
var items = [Int]()
mutating func push(_ item: Int) {
items.append(item)
}
mutating func pop() -> Int {
return items.removeLast()
}
}
- 这个结构体在栈中使用一个名为 items 的 Array 属性来存储值，Stack 提供了两个方法：push( _: ) 和 pop()，用来向栈中压入值以及从栈中移除值，这些方法被标记为 mutating，因为它们需要修改结构体的 items 数组。
- 上面的 IntStack 结构体只能用于 Int 类型。不过可以定义一个泛型 Stack 结构体，从而能够处理任意类型的值。
- 下面是相同代码的泛型版本：
// 泛型的栈
struct Stack<Element> {
var items = [Element]()
mutating func push(_ item: Element) {
items.append(item)
}
mutating func pop() -> Element {
return items.removeLast()
}
}
var stackOfStrings = Stack<String>()
print("字符串元素入栈: ")
stackOfStrings.push("google")
stackOfStrings.push("runoob")
print(stackOfStrings.items);
let deletetos = stackOfStrings.pop()
print("出栈元素: " + deletetos)
var stackOfInts = Stack<Int>()
print("整数元素入栈: ")
stackOfInts.push(1)
stackOfInts.push(2)
print(stackOfInts.items);
- 执行结果为：
字符串元素入栈:
["google", "runoob"]
出栈元素: runoob
整数元素入栈:
[1, 2]
- Stack 基本上和 IntStack 相同，占位类型参数 Element 代替了实际的 Int 类型。
- 以上实例中 Element 在如下三个地方被用作占位符：
-
- 创建 items 属性，使用 Element 类型的空数组对其进行初始化。
-
- 指定 push( _: ) 方法的唯一参数 item 的类型必须是 Element 类型。
-
- 指定 pop() 方法的返回值类型必须是 Element 类型。
③ 扩展泛型类型
- 当扩展一个泛型类型的时候（使用 extension 关键字），并不需要在扩展的定义中提供类型参数列表。更加方便的是，原始类型定义中声明的类型参数列表在扩展里是可以使用的，并且这些来自原始类型中的参数名称会被用作原始定义中类型参数的引用。
- 如下所及，扩展了泛型类型 Stack，为其添加了一个名为 topItem 的只读计算型属性，它将会返回当前栈顶端的元素而不会将其从栈中移除：
struct Stack<Element> {
var items = [Element]()
mutating func push(_ item: Element) {
items.append(item)
}
mutating func pop() -> Element {
return items.removeLast()
}
}
extension Stack {
var topItem: Element? {
return items.isEmpty ? nil : items[items.count - 1]
}
}
var stackOfStrings = Stack<String>()
print("字符串元素入栈: ")
stackOfStrings.push("google")
stackOfStrings.push("runoob")
if let topItem = stackOfStrings.topItem {
print("栈中的顶部元素是：\\(topItem).")
}
print(stackOfStrings.items)
- 实例中 topItem 属性会返回一个 Element 类型的可选值。当栈为空的时候，topItem 会返回 nil；当栈不为空的时候，topItem 会返回 items 数组中的最后一个元素。
- 以上程序执行输出结果为：
字符串元素入栈:
栈中的顶部元素是：runoob.
["google", "runoob"]
④ 类型约束
- 类型约束指定了一个必须继承自指定类的类型参数，或者遵循一个特定的协议或协议构成。
- 类型约束语法：可以写一个在一个类型参数名后面的类型约束，通过冒号分割，来作为类型参数链的一部分，这种作用于泛型函数的类型约束的基础语法如下所示（和泛型类型的语法相同）：
func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
// 这里是泛型函数的函数体部分
}
- 上面这个函数有两个类型参数：第一个类型参数 T，有一个要求 T 必须是 SomeClass 子类的类型约束；第二个类型参数 U，有一个要求 U 必须符合 SomeProtocol 协议的类型约束。
- 在一个类型参数后面放置协议或者是类型，比如要求类型参数 T 遵循 Equatable 协议：
func test<T: Equatable>(_ a: T, _ b: T) -> Bool {
return a == b
}
⑤ 关联类
- Swift 中使用 associatedtype 关键字来设置关联类型实例。
- 定义一个 Container 协议，该协议定义一个关联类型 ItemType，Container 协议只指定了三个任何遵从 Container 协议的类型必须提供的功能，遵从协议的类型在满足这三个条件的情况下也可以提供其他额外的功能，如下所示：
// Container 协议
protocol Container {
associatedtype ItemType
// 添加一个新元素到容器里
mutating func append(_ item: ItemType)
// 获取容器中元素的数
var count: Int { get }
// 通过索引值类型为 Int 的下标检索到容器中的每一个元素
subscript(i: Int) -> ItemType { get }
}
// Stack 结构体遵从 Container 协议
struct Stack<Element>: Container {
// Stack<Element> 的原始实现部分
var items = [Element]()
mutating func push(_ item: Element) {
items.append(item)
}
mutating func pop() -> Element {
return items.removeLast()
}
// Container 协议的实现部分
mutating func append(_ item: Element) {
self.push(item)
}
var count: Int {
return items.count
}
subscript(i: Int) -> Element {
return items[i]
}
}
var tos = Stack<String>()
tos.push("google")
tos.push("runoob")
tos.push("taobao")
// 元素列表
print(tos.items)
// 元素个数
print( tos.count)
- 以上程序执行结果为：
["google", "runoob", "taobao"]
3
- 在遵循了协议实现的时候才去指定真正类型，这里可以不指定，Swift 可以自己推断合适的 ItemType 为 Int，就可以写一个泛型版本：
protocol Container {
// 占位符
associatedtype ItemType
mutating func append(_ item: ItemType)
var count: Int { get }
subscript(i: Int) -> ItemType { get }
}
struct Stack<Element>: Container {
// original Stack<Element> implementation
var items = [Element]()
mutating func push(_ item: Element) {
items.append(item)
}
mutating func pop() -> Element {
return items.removeLast()
}
// conformance to the Container protocol
mutating func append(_ item: Element) {
self.push(item)
}
var count: Int {
return items.count
}
subscript(i: Int) -> Element {
return items[i]
}
}
- 当然可以给关联类型添加约束：
protocol Container {
associatedtype Item: Equatable
mutating func append(_ item: Item)
var count: Int { get }
subscript(i: Int) -> Item { get }
}
⑥ Where 语句
- 类型约束能够确保类型符合泛型函数或类的定义约束。
- 可以在参数列表中通过 where 语句定义参数的约束，也可以写一个 where 语句，紧跟在在类型参数列表后面，where 语句后跟一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型间的等价(equality)关系。
- 定义一个名为 allItemsMatch 的泛型函数，用来检查两个 Container 实例是否包含相同顺序的相同元素，如果所有的元素能够匹配，那么返回 true，反之则返回 false。如下所示：
// Container 协议
protocol Container {
associatedtype ItemType
// 添加一个新元素到容器里
mutating func append(_ item: ItemType)
// 获取容器中元素的数
var count: Int { get }
// 通过索引值类型为 Int 的下标检索到容器中的每一个元素
subscript(i: Int) -> ItemType { get }
}
// // 遵循Container协议的泛型TOS类型
struct Stack<Element>: Container {
// Stack<Element> 的原始实现部分
var items = [Element]()
mutating func push(_ item: Element) {
items.append(item)
}
mutating func pop() -> Element {
return items.removeLast()
}
// Container 协议的实现部分
mutating func append(_ item: Element) {
self.push(item)
}
var count: Int {
return items.count
}
subscript(i: Int) -> Element {
return items[i]
}
}
// T1.ItemType == T2.ItemType 表示类型相等，T1.ItemType: Equatable 表示都遵循Equatable
func compare<T1: Container, T2: Container>(_ stack1: T1, _ stack2: T2) -> Bool where T1.ItemType == T2.ItemType, T1.ItemType: Equatable {
guard stack1.count == stack2.count else {
return false
}
for i in 0..<stack1.count {
if stack1[i] != stack2[i] {
return false
}
}
return true
}
// 扩展，将 Array 当作 Container 来使用
extension Array: Container {}
func allItemsMatch<C1: Container, C2: Container>
(_ someContainer: C1, _ anotherContainer: C2) -> Bool
where C1.ItemType == C2.ItemType, C1.ItemType: Equatable {
// 检查两个容器含有相同数量的元素
if someContainer.count != anotherContainer.count {
return false
}
// 检查每一对元素是否相等
for i in 0..<someContainer.count {
if someContainer[i] != anotherContainer[i] {
return false
}
}
// 所有元素都匹配，返回 true
return true
}
var tos = Stack<String>()
tos.push("google")
tos.push("runoob")
tos.push("taobao")
var aos = ["google", "runoob", "taobao"]
if allItemsMatch(tos, aos) {
print("匹配所有元素")
} else {
print("元素不匹配")
}
- 以上程序执行输出结果为：
匹配所有元素
- 当然也可以直接写在 extension 中：
//T1.ItemType == T2.ItemType 表示类型相等，T1.ItemType: Equatable 表示都遵循Equatable
func compare<T1: Container, T2: Container>(_ stack1: T1, _ stack2: T2) -> Bool where T1.ItemType == T2.ItemType, T1.ItemType: Equatable {
guard stack1.count == stack2.count else {
return false
}
for i in 0..<stack1.count {
if stack1[i] != stack2[i] {
return false
}
}
return true
}
extension Container where ItemType: Equatable {}
- 有时候希望泛型指定类型的时候拥有特定功能，比如：
extension Container where ItemType == Int {
func test() {
print("only ItemType == Int")
}
}
- 当 ItemType 是 Double 的时候，是找不到 test 方法的：
二、源码分析
① 泛型函数
- 以下面一个简单的泛型函数为例：
// 简单的泛型函数
func test<T>(_ value: T) -> T{
// 询问metadata中VWT:size,stride分配内存空间
// 调用VWT-copy方法拷贝值
// 返回temp
// 调用VWT-destory方法销毁局部变量以上是关于已知一个int型数组arraylist[]，写出冒泡排序法的主要内容，如果未能解决你的问题，请参考以下文章
Java— “ArrayList＜Integer＞如何转化为int[ ]数组”