算法题

一、冒泡排序

对比相邻的两个元素的大小，如果大于（或者小于）就交换他们的位置

    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.count-1 {
    print(numbers[i])
    
    for j in 0..<numbers.count-1-i {
         if numbers[j] > 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<j {
        while i<j && array[j] >= key {
            j -= 1
        }
        array[i] = array[j]

        while i<j && array[i] <= key {
            i += 1
        }
        array[j] = array[i]
    }
    array[i] = key

    qucikSort(array: &array, left: left, right: i-1)
    qucikSort(array: &array, left: i+1, right: right)
}

    var numbers :[Int] = [12,45,67,79,24,6,8,99,64,37]
    qucikSort(array: &numbers, left: 0, right: numbers.count-1)
    print(numbers)

五、 二分查找

存储在数组中(例如一维数组)；数组元素为有序(例如升序)。

-(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]<key)
            low=mid+1;              //继续在R[mid+1..high]中查找
        else
            high=mid-1;            //继续在R[low..mid-1]中查找

    }

    return -1;//当low>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;
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 158,847评论 4赞 362
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,208评论 1赞 292
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,587评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,942评论 0赞 205
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,332评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,587评论 1赞 218
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,853评论 2赞 312
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,568评论 0赞 198
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,273评论 1赞 242
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,542评论 2赞 246
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,033评论 1赞 260
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,373评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,031评论 3赞 236
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,073评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,830评论 0赞 195
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,628评论 2赞 274
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,537评论 2赞 269