C语言的“冒泡排序”怎么做？sort(str)什么意思？

Question

如题所述

Answer 1

对于冒泡:
可以这样考虑
外层循环式控制一共有多少个泡需要排序, 这个当然要用循环

内层循环控制把某一个泡放到正确的位置, 这个也要用循环, 因为这个泡要和所有未排序泡比较一遍, 然后才能知道自己应该处的位置

这里有两个点,明白了的话,这道题就明白了
1. 外层循环: 仅仅控制一共有多少个泡需要排序, 比如代码中a[10], 一共是10个元素
2. 内层循环: 仅仅控制把当前最大的泡放到最后, 也就是一次内层循环,仅仅把最大的那个泡放到最后了而已

把1和2综合起来看
当j=0时,把a数组10个元素中最大的泡放到最后
当j=1时,把a数组10个元素中第二大的元素放到倒数第二个位置
依次类推..直到第10大的元素,即最小的元素放到正数第一个位置

楼主可以这样测试一下,会更加清晰,把第一个循环去掉, 内层循环改为:
for(i=0; i< 10; i++) 相当于仅执行上述j=0的一次内层循环, 这个循环的作用是把最大的元素放到最后

在解释下内层循环为什么是 i<10-j 其实这个不难理解
当j=0时, 相当于 for(i=0;i<10;i++) 也就是遍历所有元素,把最大的放到最后
当j=1时, 相当于 for(i=0;i<9;i++) 这次仅仅遍历前9个元素,把前9个元素中最大的放到第九个位置, 因为第10个位置已经是最大的了,不用再次比较了.

如果实在是对嵌套循环理解不了,还有个简单的办法,把外层循环解开:
也就是可以这么写:
//----------------------------------------
for(i=0;i<10;i++) //等价于j=0
if (a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}

for(i=0;i<9;i++) //等价于j=1
if (a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
...//同上,仅仅是把i<后面的值递减,直到
for(i=0;i<1;i++) //等价于j=9
if (a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}

上面这一系列代码,等价于原来的双层嵌套循环
sort(str) 就是用户自定义的冒泡排序函数的函数名，str作为函数参数

Answer 2

sort是C++数学库中的函数，用来升序排列，sort(str)就是把str数组中的元素升序排列

Answer 3

对于冒泡:
可以这样考虑
外层循环式控制一共有多少个泡需要排序,
这个当然要用循环
内层循环控制把某一个泡放到正确的位置,
这个也要用循环,
因为这个泡要和所有未排序泡比较一遍,
然后才能知道自己应该处的位置
这里有两个点,明白了的话,这道题就明白了
1.
外层循环:
仅仅控制一共有多少个泡需要排序,
比如代码中a[10],
一共是10个元素
2.
内层循环:
仅仅控制把当前最大的泡放到最后,
也就是一次内层循环,仅仅把最大的那个泡放到最后了而已
把1和2综合起来看
当j=0时,把a数组10个元素中最大的泡放到最后
当j=1时,把a数组10个元素中第二大的元素放到倒数第二个位置
依次类推..直到第10大的元素,即最小的元素放到正数第一个位置
楼主可以这样测试一下,会更加清晰,把第一个循环去掉,
内层循环改为:
for(i=0;
i<
10;
i++)
相当于仅执行上述j=0的一次内层循环,
这个循环的作用是把最大的元素放到最后
在解释下内层循环为什么是
i<10-j
其实这个不难理解
当j=0时,
相当于
for(i=0;i<10;i++)
也就是遍历所有元素,把最大的放到最后
当j=1时,
相当于
for(i=0;i<9;i++)
这次仅仅遍历前9个元素,把前9个元素中最大的放到第九个位置,
因为第10个位置已经是最大的了,不用再次比较了.
如果实在是对嵌套循环理解不了,还有个简单的办法,把外层循环解开:
也就是可以这么写:
//----------------------------------------
for(i=0;i<10;i++)
//等价于j=0
if
(a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
for(i=0;i<9;i++)
//等价于j=1
if
(a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
...//同上,仅仅是把i<后面的值递减,直到
for(i=0;i<1;i++)
//等价于j=9
if
(a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
上面这一系列代码,等价于原来的双层嵌套循环
sort(str)
就是用户自定义的冒泡排序函数的函数名，str作为函数参数

Answer 4

对于冒泡:
可以这样考虑
外层循环式控制一共有多少个泡需要排序,
这个当然要用循环
内层循环控制把某一个泡放到正确的位置,
这个也要用循环,
因为这个泡要和所有未排序泡比较一遍,
然后才能知道自己应该处的位置
这里有两个点,明白了的话,这道题就明白了
1.
外层循环:
仅仅控制一共有多少个泡需要排序,
比如代码中a[10],
一共是10个元素
2.
内层循环:
仅仅控制把当前最大的泡放到最后,
也就是一次内层循环,仅仅把最大的那个泡放到最后了而已
把1和2综合起来看
当j=0时,把a数组10个元素中最大的泡放到最后
当j=1时,把a数组10个元素中第二大的元素放到倒数第二个位置
依次类推..直到第10大的元素,即最小的元素放到正数第一个位置
楼主可以这样测试一下,会更加清晰,把第一个循环去掉,
内层循环改为:
for(i=0;
i<
10;
i++)
相当于仅执行上述j=0的一次内层循环,
这个循环的作用是把最大的元素放到最后
在解释下内层循环为什么是
i<10-j
其实这个不难理解
当j=0时,
相当于
for(i=0;i<10;i++)
也就是遍历所有元素,把最大的放到最后
当j=1时,
相当于
for(i=0;i<9;i++)
这次仅仅遍历前9个元素,把前9个元素中最大的放到第九个位置,
因为第10个位置已经是最大的了,不用再次比较了.
如果实在是对嵌套循环理解不了,还有个简单的办法,把外层循环解开:
也就是可以这么写:
//----------------------------------------
for(i=0;i<10;i++)
//等价于j=0
if
(a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
for(i=0;i<9;i++)
//等价于j=1
if
(a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
...//同上,仅仅是把i<后面的值递减,直到
for(i=0;i<1;i++)
//等价于j=9
if
(a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
上面这一系列代码,等价于原来的双层嵌套循环
sort(str)
就是用户自定义的冒泡排序函数的函数名，str作为函数参数