黑马程序员技术交流社区

标题: 关于排序的问题 [打印本页]

---

作者: 黑马_白马    时间: 2014-6-20 09:24
标题: 关于排序的问题


/*
关于《开发实战经典》这本书 P83 的范例调试。
数组排序；
*/
class ArrayRefDemo3
{
        public static void main(String[] args)
        {
                int score[]={67,89,87,69,90,100,75,90};
                int age[]={31,30,18,17,8,9,1,39};
                sort(score);
                print(score);
                System.out.println("\n----------------------------");
                sort(age);
                print(age);
        }
        public static void sort(int temp[])
        {
                for (int i=1;i<temp.length ;i++ )//数组排序
                {
                        for (int j=0;j<temp.length;j++ )        //这个方法是冒泡排序吗？？
                                                                        //我怎么看着像选择排序~~~
                        {
                                if (temp<temp[j])
                                {
                                        int x=temp;
                                        temp=temp[j];        //交换位置操作
                                        temp[j]=x;
                                }
                        }
                }
        }
        public static void print(int temp[])//输出数组内容
        {
                for (int i=0;i<temp.length;i++ )
                {
                        System.out.print(temp+"\t");
                }
        }
}
//这个排序看的我好纠结，书上说是冒泡，我跟着它绕了半天也总感觉是选择；
//各位看官，这个到底是啥？？？求解；
//希望各位不吝赐教。

---

作者: uu993    时间: 2014-6-20 09:35
public static void sort(int temp[])
        {
                for (int i=1;i<temp.length ;i++ )//数组排序
                {
                        for (int j=0;j<temp.length-i-1;j++ )        //这样才是冒泡排序~
                                                                        //我怎么看着像选择排序~~~
                        {
                                if (temp<temp[j])
                                {
                                        int x=temp;
                                        temp=temp[j];        //交换位置操作
                                        temp[j]=x;
                                }
                        }
                }
        }

---

作者: liletian2104    时间: 2014-6-20 09:47
可以怀疑书上写的可能有问题，可以看一下经典的写法

---

作者: 坠花湮    时间: 2014-6-20 09:49


书上这个例子是有问题的，你跟踪一下循环就清楚了。

public class SortBubbleTest {
//选择排序
        public static void selectSort(int[] array) {

                for (int x = 0; x < array.length - 1; x++) {
                        for (int y = x + 1; y < array.length; y++) {
                                if (array[x] > array[y]) {
                                        int temp;
                                        temp = array[y];
                                        array[y] = array[x];
                                        array[x] = temp;

                                }
                        }

                }

        }
//冒泡排序：冒泡是通过一轮一轮的比较，每轮都是把最小（大）的数放到前排，类型冒泡效果。
        public static void bubbleSort(int[] array) {
                for (int x = 0; x < array.length; x++) {
                        for (int y = 0; y < array.length - x - 1; y++) {
                                if (array[y] > array[y + 1]) {
                                        int temp;
                                        temp = array[y + 1];
                                        array[y + 1] = array[y];
                                        array[y] = temp;

                                }
                        }

                }

        }

        // 打印数组
        public static void printArray(int[] array) {
                for (int i = 0; i < array.length; i++) {
                        System.out.print(array + ",");
                }
                System.out.println();
        }

        public static void main(String[] args) {
                int[] array = { 12, 9, 15, 25, 6, 3 };
                printArray(array);
                // selectSort(array);
                bubbleSort(array);
                printArray(array);

        }

}

---

作者: Crystal静新    时间: 2014-6-20 09:59
一、冒泡排序(BubbleSort)
1. 基本思想：
　　两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。
2. 排序过程：
　　设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。

/**
冒泡排序：执行完一次内for循环后，最大的一个数放到了数组的最后面。相邻位置之间交换
*/
public class BubbleSort2{
        public static void main(String[] args){
                int[] a = {3,5,9,4,7,8,6,1,2};
                BubbleSort2 bubble = new BubbleSort2();
                bubble.bubble(a);
                for(int num:a){
                        System.out.print(num + " ");
                }
        }
       
        public void bubble(int[] a){
                for(int i=a.length-1;i>0;i--){
                        for(int j=0;j<i;j++){
                                if(new Integer(a[j]).compareTo(new Integer(a[j+1]))>0){
                                        swap(a,j,j+1);
                                }
                        }
                }
        }
       
        public void swap(int[] a,int x,int y){
                int temp;
                temp=a[x];
                a[x]=a[y];
                a[y]=temp;
        }
}

/**
* 冒泡排序：执行完一次内for循环后，最小的一个数放到了数组的最前面（跟那一个排序算法* 不一样）。相邻位置之间交换
*/

public class BubbleSort {   
  
    /**  
     * 排序算法的实现，对数组中指定的元素进行排序  
     * @param array 待排序的数组  
     * @param from 从哪里开始排序  
     * @param end 排到哪里  
     * @param c 比较器  
     */  
    public void bubble(Integer[] array, int from, int end) {   
        //需array.length - 1轮比较   
        for (int k = 1; k < end - from + 1; k++) {   
            //每轮循环中从最后一个元素开始向前起泡，直到i=k止，即i等于轮次止   
            for (int i = end - from; i >= k; i--) {   
                //按照一种规则（后面元素不能小于前面元素）排序   
                if ((array[i].compareTo(array[i - 1])) < 0) {   
                    //如果后面元素小于了（当然是大于还是小于要看比较器实现了）前面的元素，则前后交换   
                    swap(array, i, i - 1);   
                }   
            }   
        }   
    }   
       
        /**  
     * 交换数组中的两个元素的位置  
     * @param array 待交换的数组  
     * @param i 第一个元素  
     * @param j 第二个元素  
     */  
    public void swap(Integer[] array, int i, int j) {   
        if (i != j) {//只有不是同一位置时才需交换   
            Integer tmp = array[i];   
            array[i] = array[j];   
            array[j] = tmp;   
        }   
    }   

       
    /**   
    * 测试   
    * @param args   
    */  
    public static void main(String[] args) {   
        Integer[] intgArr = { 7, 2, 4, 3, 12, 1, 9, 6, 8, 5, 11, 10 };   
        BubbleSort bubblesort = new BubbleSort();   
        bubblesort.bubble(intgArr,0,intgArr.length-1);
        for(Integer intObj:intgArr){
                        System.out.print(intObj + " ");
        }
    }   
}  

---

作者: 张周飞    时间: 2014-6-20 11:57
最简单的排序：首先引入util的Arrays类    import  java.util.Arrays；
                      之后对数组进行操作：
                       具体如下
                         int[] mun={705,523,892,21,68,9};
                          Array.sort(mun);//添加数组。
                          System.out.println(Array.sort(mun));

---

作者: 黑马_白马    时间: 2014-6-20 14:39

Crystal静新 发表于 2014-6-20 09:59
一、冒泡排序(BubbleSort)
1. 基本思想：
　　两两比较待排序数据元素的大小，发现两个数据元素的次序相反 ...

哥们，您写的好专业~

---

作者: 黑马_白马    时间: 2014-6-20 14:43

坠花湮 发表于 2014-6-20 09:49
书上这个例子是有问题的，你跟踪一下循环就清楚了。

public class SortBubbleTest {

指正一下，您别介意；
第一个函数名要改成selectSort:lol
您写错了

---

作者: 黑马_白马    时间: 2014-6-20 14:47

坠花湮 发表于 2014-6-20 09:49
书上这个例子是有问题的，你跟踪一下循环就清楚了。

public class SortBubbleTest {

不过谢谢你。我就是跟着它绕了半天，不仅比较次数增多了，而且怎么绕也不是冒泡；
真不如毕老师的算法好。

---

作者: 黑马_白马    时间: 2014-6-20 14:50

liletian2104 发表于 2014-6-20 09:47
可以怀疑书上写的可能有问题，可以看一下经典的写法

比如呢？

---

作者: 黑马_白马    时间: 2014-6-20 14:52

uu993 发表于 2014-6-20 09:35
public static void sort(int temp[])
        {
                for (int i=1;i

您老这个能运行过吗？

---

作者: 坠花湮    时间: 2014-6-21 08:54

黑马_白马 发表于 2014-6-20 14:43
指正一下，您别介意；
第一个函数名要改成selectSort
您写错了

哈哈，这个不能说写错，方法名定义不明确。  不过多谢，这是细节

---

作者: 黑马_白马    时间: 2014-6-21 09:20

坠花湮 发表于 2014-6-21 08:54
哈哈，这个不能说写错，方法名定义不明确。  不过多谢，这是细节

嗯嗯！嘻嘻

---

作者: 坠花湮    时间: 2014-6-21 13:59

黑马_白马 发表于 2014-6-21 09:20
嗯嗯！嘻嘻

:lol:lol:lol:lol

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2