冒泡排序法以及优化后的排序算法

    #include <stdio.h>
    int main()
    {
        int nums[10] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
        int i, j,k, temp;
        //冒泡排序算法:进行 n-1 轮比较
        for(i=0; i<10-1; i++)
        {
            //每一轮比较前 n-1-i 个,也就是说,已经排序好的最后 i 个不用比较
            for(j=0; j<10-1-i; j++)
            {
                if(nums[j] > nums[j+1])
                {
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
                printf("\n");
                for(k=0; k<10; k++)
                {
                    printf("%d ", nums[k]);
                }

            }
        }
        printf("\n\n");
        for(i=0; i<10; i++){
        printf("%d ", nums[i]);
        }
        printf("\n");

        return 0;
    }

 

执行结果

9 10 8 7 6 5 4 3 2 1 
9 8 10 7 6 5 4 3 2 1 
9 8 7 10 6 5 4 3 2 1 
9 8 7 6 10 5 4 3 2 1 
9 8 7 6 5 10 4 3 2 1 
9 8 7 6 5 4 10 3 2 1 
9 8 7 6 5 4 3 10 2 1 
9 8 7 6 5 4 3 2 10 1 
9 8 7 6 5 4 3 2 1 10 
8 9 7 6 5 4 3 2 1 10 
8 7 9 6 5 4 3 2 1 10 
8 7 6 9 5 4 3 2 1 10 
8 7 6 5 9 4 3 2 1 10 
8 7 6 5 4 9 3 2 1 10 
8 7 6 5 4 3 9 2 1 10 
8 7 6 5 4 3 2 9 1 10 
8 7 6 5 4 3 2 1 9 10 
7 8 6 5 4 3 2 1 9 10 
7 6 8 5 4 3 2 1 9 10 
7 6 5 8 4 3 2 1 9 10 
7 6 5 4 8 3 2 1 9 10 
7 6 5 4 3 8 2 1 9 10 
7 6 5 4 3 2 8 1 9 10 
7 6 5 4 3 2 1 8 9 10 
6 7 5 4 3 2 1 8 9 10 
6 5 7 4 3 2 1 8 9 10 
6 5 4 7 3 2 1 8 9 10 
6 5 4 3 7 2 1 8 9 10 
6 5 4 3 2 7 1 8 9 10 
6 5 4 3 2 1 7 8 9 10 
5 6 4 3 2 1 7 8 9 10 
5 4 6 3 2 1 7 8 9 10 
5 4 3 6 2 1 7 8 9 10 
5 4 3 2 6 1 7 8 9 10 
5 4 3 2 1 6 7 8 9 10 
4 5 3 2 1 6 7 8 9 10 
4 3 5 2 1 6 7 8 9 10 
4 3 2 5 1 6 7 8 9 10 
4 3 2 1 5 6 7 8 9 10 
3 4 2 1 5 6 7 8 9 10 
3 2 4 1 5 6 7 8 9 10 
3 2 1 4 5 6 7 8 9 10 
2 3 1 4 5 6 7 8 9 10 
2 1 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 

1 2 3 4 5 6 7 8 9 10 

优化后的算法,可以通过内循环查看是否已经排序好,如果排序好,就不再需要排序。

    #include <stdio.h>
    int main()
    {
        int nums[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int i, j,k, temp, isSorted;
        //冒泡排序算法:进行 n-1 轮比较
        for(i=0; i<10-1; i++)
        {
            isSorted = 1;
            //每一轮比较前 n-1-i 个,也就是说,已经排序好的最后 i 个不用比较
            for(j=0; j<10-1-i; j++)
            {   
                if(nums[j] > nums[j+1])
                {
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                    isSorted = 0;
                }
                
                printf("\n");
                for(k=0; k<10; k++)
                {
                    printf("%d ", nums[k]);
                }

            }
           if(isSorted)  break; 
        }
        printf("\n\n");
        for(i=0; i<10; i++){
        printf("%d ", nums[i]);
        }
        printf("\n");

        return 0;
    }

执行结果

1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 

1 2 3 4 5 6 7 8 9 10 

如果不优化,程序就会出现空跑。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
冒泡排序是一种简单但效率较低的排序算法,其基本思想是通过比较相邻元素的大小,将较大的元素逐渐交换到数组的末尾。该算法需要进行多次遍历,并且每次遍历都会比较相邻元素的大小,导致时间复杂度较高。 如果要对冒泡排序进行优化,可以采取以下几种方法: 1. 设置标志位:在每次遍历过程中,如果没有发生元素交换,则说明数组已经有序,因此可以提前结束排序过程,减少不必要的比较次数,从而减少时间复杂度。 2. 添加有序区间:每次外层循环后,可以确定一个最大的元素已经移动到数组的末尾。可以将该元素的下标记录下来,并在下一次遍历时,只需要比较到该下标即可。这样可以减少比较次数,进一步优化排序算法。 3. 对于部分有序的数组,可以采用鸡尾酒排序。鸡尾酒排序是对冒泡排序的改进,其思想是在一次遍历中,同时从左到右和从右到左两个方向进行比较和交换。这样可以更快地将较大和较小的元素移到正确的位置上。 4. 利用递归进行优化。可以将冒泡排序改为递归形式,每次遍历过程只需要比较相邻元素的大小,并交换它们。递归的终止条件可以是遍历过程中没有发生元素交换,或者到达了数组的末尾。这样可以减少外层循环的遍历次数。 通过以上优化方法的运用,可以提高冒泡排序算法的效率,减少排序所需的比较次数和交换次数,从而更快地完成排序过程。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值