public class ArrayDemo06
{
public static void main(String[] args)
{
int score[]={67,89,87,69,90,100,75,90};
for(int i=1;i<score.length;i++)
{
for(j=0;j<score.length;j++)
{
if(score[i]<score[j])
{
int temp=score[i];
score[i]=score[j];
score[j]=temp;
}
}
}
for(int i=0;i<score.length;i++)
{
Syestem.out.print(score[i]+"\t");
}
}
}
{
public static void main(String[] args)
{
int a[]={67,89,87,69,90,100,75,90};
int temp;
for(int i=0;i<a.length;i++)
{
for(int j=i+1;j<a.length;j++)
{
if(a[i]>a[j])
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+"\t");
}
}
}
这是我自己写的。怎么跟那个不一样啊？他那个我看不懂。。怎么这么乱啊？
冒泡排序是相邻两个元素排序，选择排序是每次选定一个元素i，然后i跟后面的元素排序
LZ的代码比数上的代码好，因为比较过的元素以后不需要再比较了，所以j没必要从0开始循环
不过选择排序是一种不稳定排序，所以如果对元素排序前相同元素的顺序没什么特别要求，那就无所谓，否则还是用其他排序方法好一些
要让数组中的元素从小到大排列
第一次循环，得到最大的数放在数组的最后
第二次循环，得到次大的数放在数组次后的位置
依此类推... int a[] = {8, 7, 6, 5, 3, 4, 1, 2};
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}而选择排序将交换次数减少到了O(N)级，不需要发现前边比后边的大就得交换一次，选择排序一般是这样的：思想:
先选出最小的数据项，再选出次小的，依此类推...
先用一个变量记录第一个元素的下标，再将这个下标对应的元素值与其他元素值进行比较，如果其他元素值小于这个值，则更新这个变量为较小的那个下标，
比较完所有元素以后，交换一次(将最小的元素放在第一位)，再比较下边的第N-1个元素，每趟比较只交换一次。 int a[] = {8, 7, 6, 5, 3, 4, 1, 2};
int min = 0;
for (int i = 0; i < a.length; i++) {
min = i;
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[min]) {
min = j;
}
}
int temp = a[i];
a[i] = a[min];
a[min] = temp;
}
给段sample吧，不明白的人好好体会一下冒泡和选择的区别public class dx
{
public static void main(String[] args)
{
int a[]={67,89,87,69,90,100,75,90};
int temp;
for(int i=0;i<a.length;i++)
{
for(int j=1;j<a.length-i;j++)
{
if(a[j]<a[j-1]) //冒泡排序是每次比较相邻两个元素，即a[j] a[j-1]比较
{ //选择排序是每次和一个固定位置元素比较，即a[i] [j]比较
temp=a[j];
a[j]=a[j-1];
a[j-1]=temp;
}
}
}
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+"\t");
}
}
}
但是也不是选择排序，如果数组比较极端，如int a[]={100,90,90,89,87,75,69,67},那么楼主的这种写法交换次数势必会很多，为O(N2)级，这显然不符合选择排序的本意,选择排序每趟比较只交换一次(交换次数从O(N2)减少到了O(N)级，但比较次数仍然是O(N2))
int a[] = {8, 7, 6, 5, 3, 4, 1, 2};
int min = 0;
for (int i = 0; i < a.length; i++) {
min = i;
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[min]) {
min = j;
}
}
int temp = a[i];
a[i] = a[min];
a[min] = temp;
}
public class dx
{
public static void main(String[] args)
{
int a[]={67,89,87,69,90,100,75,90};//这是先值放在数组里面
int temp;
for(int i=0;i<a.length;i++) //这个for循环值从0开始
{
for(int j=i+1;j<a.length;j++)//这个for循环从1开始
{
if(a[i]>a[j]) //然后比较数组中的前后值大小
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+"\t"); //打印出排序结果
}
}
}
这段冒泡排序笔试的时候会经常出现
最好的效率当然是O(1)了，然后就是快速排序，其平均效率为O(N*logN)。
冒泡排序思想：相邻元素两两比较
大循环 {
第一次大循环：小循环 {
第一次：比较相邻两个元素 3, 2 -> 交换 2, 3 -> 数组变为 2,3,1,1
第二次：比较相邻两个元素 3, 1 -> 交换 1, 3 -> 数组变为 2,1,3,1
第三次：比较相邻两个元素 3, 1 -> 交换 1, 3 -> 数组变为 2,1,1,3
小循环结束
}
第二次大循环：小循环 {
第一次：比较相邻两个元素 2, 1 -> 交换 1, 2 -> 数组变为 1,2,1,3
第二次：比较相邻两个元素 2, 1 -> 交换 2, 1 -> 数组变为 1,1,2,3
小循环结束
}
第三次大循环：小循环 {
第一次：比较相邻两个元素 1, 1 -> 不交换 -> 数组变为 1,1,2,3
小循环结束
}
第四次大循环：小循环 {
不满足小循环条件，小循环结束
}
}
排序结束 数组变为 1，1，2，3
选择排序思想：每次取一个位置，在该位置后续的元素中找到最小的元素，然后和之前取出的位置的元素交换
大循环 {
第一次大循环（设置比较位置0， 比较位置数为3）：小循环 {
第一次：比较位置元素和第二个元素比较 3, 2 -> 重新设置比较位置 1，比较位置数为 2
第二次：比较位置元素和第三个元素比较 2, 1 -> 重新设置比较位置 2，比较位置数为 1
第三次：比较位置元素和第四个元素比较 1, 1 -> 不改变比较位置
小循环结束
}
比较位置的元素和第一个元素交换 -> 数组变为 1,2,3,1 第二次大循环（设置比较位置1， 比较位置数为2）：小循环 {
第一次：比较位置元素和第三个元素比较 2, 3 -> 不改变比较位置
第二次：比较位置元素和第四个元素比较 2, 1 -> 重新设置比较位置 3，比较位置数为 1
小循环结束
}
比较位置的元素和第二个元素交换 -> 数组变为 1,1,3,2 第二次大循环（设置比较位置2， 比较位置数为3）：小循环 {
第一次：比较位置元素和第四个元素比较 3, 2 -> 重新设置比较位置 3，比较位置数为 2
小循环结束
}
比较位置的元素和第三个元素交换 -> 数组变为 1,1,2,3 第四次大循环：小循环 {
不满足小循环条件，小循环结束
}
}
排序结束 数组变为 1，1，2，3
List<Integer> list = Arrays.asList(a);
Collections.sort(list);
for(int i = 0; i < list.size(); i ++){
System.out.println(list.get(i));
}