一、冒泡排序
对比相邻的两个元素的大小，如果大于（或者小于）就交换他们的位置
NSMutableArray *array =[NSMutableArray arrayWithObjects:@89,@35,@56,@2,@45,@33,@27,@74,@14,@8,nil];
for(int i =0; i < array.count; i++) {
for(int j =0; j < array.count-1-i; j++) {
if([array[j+1]intValue] < [array[j]intValue]) {
//int temp = [array[j] intValue];
//array[j] = array[j + 1];
//array[j + 1] = [NSNumber numberWithInt:temp];
[array exchangeObjectAtIndex:j withObjectAtIndex:j+1];
}
}
}
NSLog(@"冒泡排序%@",array);
//swift代码
var numbers :[Int] = [12,45,67,79,24,6,8,99,64,37]
for i in 0.. numbers[j+1] {
let temp = numbers[j]
numbers[j] = numbers[j+1]
numbers[j+1] = temp
}
}
}
//排序结束
print(numbers)
二、选择排序
找到最小的元素，放到数组的最前面，重复执行直到结束
NSMutableArray *array =[NSMutableArray arrayWithObjects:@89,@35,@56,@2,@45,@33,@27,@74,@14,@8,nil];
for(int i =0; i < array.count; i++) {
for(int j = i +1; j < array.count; j++) {
if([array[i] intValue] > [array[j]intValue]) {
int temp = [array[i]intValue];
array[i] = array[j];
array[j] = [NSNumber numberWithInt:temp];
//[array exchangeObjectAtIndex:i withObjectAtIndex:j];
}
}
}
NSLog(@"选择排序%@",array);
三、插入排序
将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。
NSMutableArray *array =[NSMutableArray arrayWithObjects:@89,@35,@56,@2,@45,@33,@27,@74,@14,@8,nil];
for(inti =1; i < array.count; i++) {
int temp = [array[i]intValue];
for(int j = i -1; j >=0&& temp < [array[j]intValue]; j--) {
array[j+1] = array[j];
array[j] = [NSNumber numberWithInt:temp];
// NSLog(@"插入排序%@",array);
}
}
NSLog(@"插入排序%@",array);
}
四、快速排序
实现原理：挖坑填数+分治法 https://blog.csdn.net/wehung/article/details/82704565
- (void)quickSortArray:(NSMutableArray*)array withLeftIndex:(NSInteger)leftIndex andRightIndex:(NSInteger)rightIndex
{
if(leftIndex >= rightIndex) {//如果数组长度为0或1时返回
return;
}
NSInteger i = leftIndex;
NSInteger j = rightIndex;
//记录比较基准数
NSInteger key = [array[leftIndex] integerValue];
while(i < j) {
/**** 首先从右边j开始查找比基准数小的值 ***/
while(i < j && [array[j]integerValue] >= key) {//如果比基准数大，继续查找
j--;
}
//如果比基准数小，则将查找到的小值调换到i的位置
array[i] = array[j];
/**** 当在右边查找到一个比基准数小的值时，就从左边i开始往后找比基准数大的值 ***/
while(i < j && [array[i]integerValue] <= key) {//如果比基准数小，继续查找
i++;
}
//如果比基准数大，则将查找到的大值调换到j的位置
array[j] = array[i];
}
//将基准数放到正确位置
array[i] =@(key);
/**** 递归排序 ***/
//排序基准数左边的
[self quickSortArray:array withLeftIndex:leftIndex andRightIndex:i - 1];
//排序基准数右边的
[self quickSortArray:array withLeftIndex:i + 1 andRightIndex:rightIndex];
}
NSMutableArray*array =[NSMutableArrayarrayWithObjects:@15,@45,@67,@5,@26,@99,@67,@14,@35,@9,nil];
[self quickSortArray:array withLeftIndex:0 andRightIndex:array.count-1];
NSLog(@"快速排序%@",array);
//swift代码
func qucikSort(array:inout [Int], left:Int, right:Int) ->Void{
if left >= right {
return
}
var i :Int = left
var j :Int = right
let key :Int = array[left]
while i= key {
j -= 1
}
array[i] = array[j]
while i 五、 二分查找
存储在数组中(例如一维数组)；数组元素为有序(例如升序)。
-(int)binSearch:(NSMutableArray*)array andKey:(int)key{
//在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回-1
int low=0, high=(int)array.count-1, mid; //置当前查找区间上、下界的初值
while(low<=high) {
if([array[low]intValue]==key)
return low;
if([array[high]intValue]==key)
return high; //当前查找区R[low..high]非空
mid=low+(high-low)/2;
/*使用(low+high)/2会有整数溢出的问题
（问题会出现在当low+high的结果大于表达式结果类型所能表示的最大值时，
这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)
不存在这个问题*/
if([array[mid]intValue]==key)
return mid; //查找成功返回
else if([array[mid]intValue]high时表示所查找区间内没有结果，查找失败
}
NSMutableArray *array =[NSMutableArray arrayWithObjects:@8,@15,@26,@32,@45,@53,@67,@74,@84,@91,nil];
int index = [self binSearch:array andKey:84];
六、有序数组归并。
将有序数组a和b的值合并到一个数组result当中，且仍然保持有序。
void mergeList(int a[], int aLen, int b[],int bLen, int result[] )
{
int p =0;// 遍历数组a的指针
int q =0;// 遍历数组b的指针
int i =0;// 记录当前存储位置
// 任一数组没有到达边界则进行遍历
while(p < aLen && q < bLen) {
// 如果a数组对应位置的值小于b数组对应位置的值
if(a[p] <= b[q]) {
// 存储a数组的值
result[i] = a[p];
// 移动a数组的遍历指针
p++;
}
else{
// 存储b数组的值
result[i] = b[q];
// 移动b数组的遍历指针
q++;
}
// 指向合并结果的下一个存储位置
i++;
}
// 如果a数组有剩余
while(p < aLen) {
// 将a数组剩余部分拼接到合并结果的后面
result[i] = a[p++];
i++;
}
// 如果b数组有剩余
while(q < bLen) {
// 将b数组剩余部分拼接到合并结果的后面
result[i] = b[q++];
i++;
}
}
// 有序数组归并
int a[5] = {1,4,6,7,9};
int b[8] = {2,3,5,6,8,10,11,12};
// 用于存储归并结果
int result[13];
// 归并操作
mergeList(a,5, b,8, result);
// 打印归并结果
printf("merge result is ");
for(int i =0; i <13; i++) {
printf("%d ", result[i]);
}
七、求1到100之间的质数
int i, j, flag;
for(i =2; i <100; i++) {
for(j =2,flag =0; j <= i; j ++) {
if(j==1||j==i) {
continue;
}
if(i%j ==0) {
flag =1;
break;
}
}
if(!flag) {
printf("%2d 是1-100内的质数\n",i);
}
}
八、写一个递归加或者乘
-(int)add:(int)num{
if(num==1){
return 1;
}
else{
return num+[self add:(num-1)];
}
}
-(int)mulity:(int)num{
if(num==1){
return 1;
}
else{
return num * [self mulity:(num-1)];
}
}
九、最大公约数;辗转相除法；
int commonDivisor(int a, int b) {
int temp = 0;
if (a < b) {
temp = a;
a = b;
b = temp;
}
while (b != 0) {
temp = a % b;
a = b;
b = temp;
}
return a;
// 扩展：最小公倍数 = (a * b)/最大公约数
}
十、在一个字符串中查找第一个只出现一次的字符
// 看到这道题时，最直观的想法是从头开始扫描这个字符串中的每个字符。当访问到某字符时拿这个字符和后面的每个字符相比较，如果在后面没有发现重复的字符，则该字符就是只出现一次的字符。如果字符串有n个字符，每个字符可能与后面的O(n)个字符相比较，因此这种思路时间复杂度是O(n2)。
// 由于题目与字符出现的次数相关，我们是不是可以统计每个字符在该字符串中出现的次数？要达到这个目的，我们需要 一个数据容器来存放每个字符的出现次数。在这个数据容器中可以根据字符来查找它出现的次数，也就是说这个容器的作用是把一个字符映射成一个数字。在常用的 数据容器中，哈希表正是这个用途。
// 哈希表是一种比较复杂的数据结构。由于比较复杂，STL中没有实现哈希表，因此需要我们自己实现一个。但由于本题的特殊性，我们只需要一个非常简单的哈希表就能满足要求。由于字符（char）是一个长度为8的数据类型，因此总共有可能256 种可能。于是我们创建一个长度为256的数组，每个字母根据其ASCII码值作为数组的下标对应数组的对应项，而数组中存储的是每个字符对应的次数。这样我们就创建了一个大小为256，以字符ASCII码为键值的哈希表。（并不仅限于英文字符，所以这里要考虑256种可能）。
// 我们第一遍扫描这个数组时，每碰到一个字符，在哈希表中找到对应的项并把出现的次数增加一次。这样在进行第二次扫描时，就能直接从哈希表中得到每个字符出现的次数了。
char findFirstChar(char* cha)
{
char result = '\0';
// 定义一个数组 用来存储各个字母出现次数
int array[256];
// 对数组进行初始化操作
for(int i=0; i<256; i++) {
array[i] =0;
}
// 定义一个指针 指向当前字符串头部
char* p = cha;
// 遍历每个字符
while(*p != '\0') {
// 在字母对应存储位置 进行出现次数+1操作
array[*(p++)]++;
// printf("%c\n",*p);//输出为当前的字符
// printf("%d\n",*p);//输出为当前字符的ASCII值
}
//记录当前遍历的字符在字符串中的位置
int i =0;
// 将P指针重新指向字符串头部
p = cha;
// 遍历每个字母的出现次数
while(*p != '\0') {
// 遇到第一个出现次数为1的字符，打印结果
if(array[*p] ==1)
{
result = *p;
break;
}
// 反之继续向后遍历
p++;
i++;
}
printf("this char 在字符串中的位置是 %d \n", i);
return result;
}
十一、字符串反转
void char_reverse(char* cha)
{
// 指向第一个字符
char* begin = cha;
// 指向最后一个字符
char* end = cha +strlen(cha) -1;
while(begin < end) {
// 交换前后两个字符,同时移动指针
char temp = *begin;
*(begin++) = *end;
*(end--) = temp;
/*
1. *(begin) 这个的含义是取当前指针指向的地址的值。
2. begin++是指先使用begin指针，然后指针地址再 +1.
合并起来*(begin++) 的意思就是找出begin指针指向的值，然后指针+1
*/
}
}
// 字符串反转
char ch[] = "hello,world";
char_reverse(ch);
printf("reverse result is %s \n", ch);
十二、字符串中的单词反转。输入为hello world for everyone!，输出为everyone! for world hello
// 将字符串整体反转
void reverseString(char *str, int start, int end) {
while (start < end) {
// 交换前后两个字符，同时移动指针
char temp = str[start];
str[start] = str[end];
str[end] = temp;
start++;
end--;
}
}
// 将字符串中的单词反转
void reverseWords(char*str) {
if (str ==NULL) {
return;
}
int start =0;
int strLength = (int)strlen(str);
// 将字符串整体反转
reverseString(str, 0, strLength -1);
for (int i =0; i < strLength; i++) {
if (i == strLength -1|| str[i+1] == *" ") {
reverseString(str, start, i);
start = i +2;
}
}
}
十三、单链表反转
// 定义一个链表
struct Node {
int data;
struct Node *next;
};
// 构造一个链表
struct Node* constructList(void)
{
// 头结点定义
struct Node *head =NULL;
// 记录当前尾结点
struct Node *cur =NULL;
for(int i =1; i <5; i++) {
struct Node *node =malloc(sizeof(structNode));
node->data= i;
// 头结点为空，新结点即为头结点
if(head ==NULL) {
head = node;
}
// 当前结点的next为新结点
else{
cur->next= node;
}
// 设置当前结点为新结点
cur = node;
}
return head;
}
// 打印链表中的数据
void printList(struct Node*head)
{
struct Node* temp = head;
while(temp !=NULL) {
printf("node is %d \n", temp->data);
temp = temp->next;
}
}
// 链表反转
struct Node* reverseList(struct Node*head)
{
// 定义遍历指针，初始化为头结点
struct Node*p = head;
// 反转后的链表头部
struct Node*newH =NULL;
// 遍历链表
while(p !=NULL) {
// 记录下一个结点
struct Node *temp = p->next;
// 当前结点的next指向新链表头部
p->next= newH;
// 更改新链表头部为当前结点
newH = p;
// 移动p指针
p = temp;
}
// 返回反转后的链表头结点
return newH;
}
struct Node* head = constructList();
printList(head);
struct Node* newHead = reverseList(head);
printList(newHead);
十四、堆排序
最大堆调整(Max Heapify): 将堆的末端子节点作调整，使得子节点永远小于父节点。
- (void)maxHeapifyWithNumbers:(NSMutableArray*)numbers start:(int)start end:(int)end {
//建立父节点指标和子节点指标
int dad = start;
int son = dad *2+1;
while(son <= end) {//若子节点指标在范围内才做比较
if(son +1<= end && [numbers[son]intValue] < [numbers[son +1]intValue]) {//先比较两个子节点大小，选择最大的
son++;
}
if([numbers[dad]intValue] > [numbers[son]intValue]) {//如果父节点大于子节点代表调整完毕，直接跳出函数
return;
}else { //否则交换父子内容再继续子节点和孙节点比较
[numbers exchangeObjectAtIndex:son withObjectAtIndex:dad];
dad = son;
son = dad *2+1;
}
}
}
/**堆排序（HeapSort）：
1、首先从最后一个父节点做最大堆调整，找出最大值，此时最大值位于根节点
2、然后将最大值和已排好元素（依次找出的最大值排出的序列，如：6 3 9 23 12 8 [15 16 17 18]）前一位元素交换位置，再将除已排好元素外的其他元素(6 3 9 23 12 8)做最大堆调整，找出最大值，此时最大值位于根节点
3、重复步骤2，直至结束
*/
- (void)heapSortWithNumbers:(NSMutableArray*)numbers {
//初始化，i从最後一个父节点开始做最大堆调整,调整结束后根节点得到最大值
for(int i = (int)numbers.count/2-1; i >=0; i--) {
[self maxHeapifyWithNumbers: numbers start:i end: (int)numbers.count-1];
}
//先将第一个元素和已排好元素前一位做交换，再重新调整，直到排序完毕
for(int i = (int)numbers.count-1; i >0; i--) {
[numbers exchangeObjectAtIndex:0 withObjectAtIndex:i];
[self maxHeapifyWithNumbers:numbers start:0 end:i - 1];
}
}
十五、不用中间变量,用两种方法交换A和B的值
// 1.中间变量
void swap(int a, int b) {
int temp = a;
a = b;
b = temp;
}
// 2.加法
void swap(int a, int b) {
a = a + b;
b = a - b;
a = a - b;
}
// 3.异或（相同为0，不同为1. 可以理解为不进位加法）
void swap(int a, int b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}