不做潜水王，那就冒泡吧

已于 2023-08-04 20:02:39 修改
阅读量88 收藏
点赞数
文章标签： 排序算法
于 2023-07-19 16:10:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_57734712/article/details/131811143
版权

数组

冒泡排序

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

  2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

  3. 针对所有的元素重复以上的步骤，除了最后一个。 

  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

#include <stdio.h>

int main(int argc, char const *argv[])
{
    int nums[] = {5,4,3,2,1};
    int nums_len = sizeof(nums) / sizeof(nums[0]);

    //遍历多少遍
    for(int i = 0;i < nums_len - 1;i++)
    {
        //将每一遍的数据比较后进行交换
        for(int j = 0;j < nums_len - i - 1;j++)
        {
            if(nums[j] > nums[j+1])
            {
                int temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }
    for(int i = 0;i < nums_len;i++)
    {
        printf("%d\t",nums[i]);
    }
    return 0;
}
力扣：三数之和
/* 给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。 */


#include <stdio.h>

int main(int argc, char const *argv[])
{
    int nums[] = {-1,2,-5,4,-2,1,-2,1,0,-2};
    int left = 0,right = 0,count = 0;
    //存放相加等于0的元素
    int ret[100][100];
    //排序
    int len = sizeof(nums) / sizeof(nums[0]);//数组长度
    for(int i = 0;i < len - 1;i++)
    {
        for(int j = 0;j < len - i - 1;j++)
        {
            if(nums[j] > nums[j+1])
            {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
    }    //排序后nums = {-5,-4,-2,-2,-2,-1,0,1,1,2,4}
    
    //for(int i = 0;i < len;i++)
    //  printf("%d\t",nums[i]);
    for(int i = 0; i < len-2; i++)
    {
        if(nums[i] > 0) // 没意义
        {
            break;
        }  
        // 去重i
        if(i > 0 && (nums[i] == nums[i-1]))
        {
            continue;
        }
        // 定位leftint i = 0与right
        left = i + 1;
        right = len - 1; 
        // 找相加能等于0的机会
        while(left < right)
        {
            int sum = nums[i]+nums[left]+nums[right];
            if(sum == 0)
            {
               /*  *(ret+count+0) = nums[i];
                *(ret+count+1) = nums[left];
                *(ret+count+2) = nums[right]; */

                ret[count][0] = nums[i];
                ret[count][1] = nums[left];
                ret[count][2] = nums[right];
                count++; // 记录满足条件的数组个数

                // 去重
                while (left < right && (nums[left] == nums[left+1]))
                {
                    left++;
                }
                 left++;
                while (left < right && (nums[right] == nums[right-1]))
                {
                    right--;
                }
                right--;
               
                
                
            }
            else if(sum > 0)
            {
                right--;
            }
            else
            {
                left++;
            }
        }
    }
    printf("count:%d\n",count);
    for(int row = 0; row < count; row++) // 行
    {
        for(int col = 0; col < 3; col++) // 列
        {
            printf("%d\t",ret[row][col]);
        }
        printf("\n");
    }
    printf("\n");
    return 0;
}
函数接口实现冒泡排序
bubble.h
bool bubble(int *array, int lenght);
bubble.c
#include<stdio.h>
#include<stdbool.h>

bool bubble(int *array,int lenght)
{
    if(array == NULL || lenght <= 0)
    {
        return false;
    }
    for(int i = 0;i < lenght - 1;i++)
    {
        for(int j = 0;j < lenght-i-1;j++)
        {
            if(array[j] > array[j+1])
            {
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
    return true;
}
main.c
#include<stdio.h>
#include<stdbool.h>

#include"bubble.h"

int main(int argc, char const *argv[])
{
    int array[]  = {5,3,2,4,1};
    int lenght = sizeof(array) / sizeof(array[0]);
    bubble(array,lenght);

    for(int i = 0;i < lenght;i++)
    {
        printf("%d\t",array[i]);
    }
    printf("\n");
    return 0;
}
通过栈空间实现冒泡排序

栈内存特点：

  • 每当一个函数被调用时，系统将自动分配一段栈内存给该函数，用于存放其局部变量

  • 每当一个函数有退出时，系统将自动回收其栈内存

  • 系统为函数分配栈内存时，遵循从上(高地址)往下(低地址)分配原则

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main(int argc, char const *argv[])
{
    int *buf = malloc(sizeof(int)*5);
    int str[] = {5,4,2,1,3};
    int len = sizeof(str) / sizeof(str[0]);
    memcpy(buf,str,sizeof(str)/sizeof(str[0])*sizeof(int));
    for(int i = 0;i < len - 1;i++)
    {
        for(int j = 0;j < len - i - 1;j++)
        {
            if(str[j] > str[j+1])
            {
                int temp = str[j];
                str[j] = str[j+1];
                str[j+1] = temp;
            }
        }
    }
    for(int i = 0;i < len;i++)
    {
        printf("%d\n",str[i]);
    }
//释放空间
    free(buf);
    buf = NULL;
    return 0;
}
 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void sort(int *buf,int len)//栈内存
{
    for(int i = 0;i < len - 1;i++)
    {
        for(int j = 0;j < len - i - 1;j++)
        {
            if(buf[j] > buf[j+1])
            {
                int temp = buf[j];
                buf[j] = buf[j+1];
                buf[j+1] = temp;
            }
        }
    }
}


int main(int argc, char const *argv[])
{
    int *buf = (int *)malloc(10*sizeof(int));
    for(int i = 10,j = 0;i > 0;i--,j++)
    {
        buf[j] = i;
        printf("%d\t",buf[j]);
    }
    printf("\n");
    sort(buf,10);
    for(int i = 0;i < 10;i++)
    {
        printf("%d\t",buf[i]);
    }

    //释放空间
    free(buf);
    buf = NULL;
    return 0;
}
函数指针——冒泡
#include <stdio.h>

typedef void (*pbubble)(int,int);
void bubble(int *buf,int len)
{
    for(int i = 0;i < len - 1;i++)
    {
        for(int j = 0;j < len - i - 1;j++)
        {
            if(buf[j] > buf[j+1])
            {
                int temp = buf[j];
                buf[j] = buf[j+1];
                buf[j+1] = temp;
            }
        }
    }
}

//void callback(int *nums,int len,void(*p)(int *,int ))
void callback(int *nums,int len,pbubble p )
{
    printf("p adder : %p\n",bubble);
    p(nums,len);
}

int main(int argc, char const *argv[])
{
    int nums[] = {5,4,3,2,1};

    //排序
    //bubble(nums,5);
    //void (*P)(int *,int ) = bubble;
    //pbubble p = bubble;
    // p(nums,5);

    //通过此函数调用bubble函数
    //此函数为回调函数
    callback(nums,5,bubble);
    
    for(int i = 0;i < 5;i++)
    {
        printf("%d\t",nums[i]);
    }
    return 0;
}
冒泡升降序——callback
#include<stdio.h>

typedef void (*pdescending_bubble)(int,int);
typedef void (*pascending_bubble)(int,int);

void descending_bubble(int *arr,int len)
{
    for(int i = 0;i < len - 1;i++)
    {
        for(int j = 0;j < len - i - 1;j++)
        {
            if(arr[j] < arr[j+1])
            {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

void ascending_bubble(int *arr,int len)
{
    for(int i = 0;i < len - 1;i++)
    {
        for(int j = 0;j < len - i - 1;j++)
        {
            if(arr[j] > arr[j+1])
            {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

void callback1(int *arr,int len,pdescending_bubble p)
{
    p(arr,len);
}

void callback2(int *arr,int len,pascending_bubble p)
{
    p(arr,len);
}
int main(int argc, char const *argv[])
{
    int arr[] = {9,4,5,3,7,6,8,1,2};
    int len = sizeof(arr) / sizeof(arr[0]);

    callback1(arr,len,descending_bubble);
    
    for(int i = 0;i < len;i++)
    {
        printf("%d\t",arr[i]);
    }
    printf("\n");

    callback2(arr,len,ascending_bubble);
    for(int i = 0;i < len;i++)
    {
        printf("%d\t",arr[i]);
    }
    return 0;
}
冒泡——回调
asc.h
#ifndef _ASC_H
#define _ASC_H

#include <stdbool.h>

// 升序
extern bool ascend(int a, int b);

// 降序
extern bool descend(int a, int b);

#endif
bubble.h
#ifndef _BUBBLE_H
#define _BUBBLE_H

#include <stdio.h>
#include <stdbool.h>

typedef bool (*sortFunc)(int , int );

void bubble(int *array, int lenght, sortFunc p);

#endif
asc.c
#include "asc.h"
// 升序
bool ascend(int a, int b)
{
    return (a-b > 0) ? true : false; // > 0
}

// 降序
bool descend(int a, int b)
{
    return (a-b < 0) ? true : false; // < 0
}
bubble.c
#include "bubble.h"
#include "asc.h"

void bubble(int *array, int n , sortFunc func)
{
    for(int i = 0; i < n-1; i++)
    {
        for(int j = 0; j < n-1-i; j++)
        {
            // 回调函数
            if(func(array[j],array[j+1]))
            {
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}
main.c
#include "bubble.h"
#include "asc.h"

int main(int argc, char const *argv[])
{
    int array[] = {3,1,2,4,5};
    // 升序
    bubble(array,5,ascend);
    for(int i = 0; i < 5; i++)
    {
        printf("%d\t",array[i]);
    } 
    printf("\n");
    // 降序
    bubble(array,5,descend);

    for(int i = 0; i < 5; i++)
    {
        printf("%d\t",array[i]);
    } 
    return 0;
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值