java 实现冒泡排序、选择排序、插入排序。

来源：互联网发布：linux ping 64字节编辑：程序博客网时间：2024/05/22 06:12
[java] view plaincopyprint?
<span style="font-size:18px;"><strong>package com.j2se;  
  
public class TestSort {  
    public static void main(String args[]) {  
        int[] a = { 1, 7, 3, 9, 2, 5, 8, 4, 6 };  
        // bubbleSort(a); // 冒泡(Bubble Sort)排序  
        // selectionSort(a); // 选择排序  
        insertSort(a); // 插入排序  
        for (int i = 0; i < a.length; i++) {  
            System.out.print(a[i] + " ");  
        }  
    }  
    /**************************************************************** 
     *  
     *  
      
     冒泡排序的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。 
        即首先比较第1个和第2个数，将小数放前，大数放后。 
        然后比较第2个数和第3个数，将小数放前，大数放后. 
        如此继续，直至比较最后两个数，将小数放前，大数放后。 
            重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再大于第2个数）. 
        将小数放前，大数放后，一直比较到最小数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最小数。 
        如此下去，直至最终完成排序。 
         
        由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。 
        用二重循环实现，外循环变量设为i，内循环变量设为j。 
            外循环重复9次，内循环依次重复9，8，...，1次。 
            每次进行比较的两个元素都是与内循环j有关的, 
                它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i, j的值依次为1,2,...10-i。 
                 
                public class BubbleSort {   
                        public static void sort(int[] data) {   
                            int temp;   
                            for (int i = 0; i < data.length; i++) {   
                                for (int j = data.length - 1; j > i; j--) {   
                                    if (data[i] > data[j]) {   
                                        temp = data[i];   
                                        data[i] = data[j];   
                                        data[j] = temp;   
                                    }   
                                }   
                            }   
                        }   
                       
                        public static void main(String[] args) {   
                            int[] a = { 4, 2, 3, 1, 5 };   
                            sort(a);   
                            for (int i = 0; i < a.length; i++)   
                                System.out.print(a[i] + " ");   
                        }   
                }   
        ================================================================================= 
         
                public class Test { 
                  public static void main(String[] args) { 
                    int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; 
 
                    System.out.print("排序前: "); 
                 
                    for (int i = 0; i < a.length; i++) 
                      System.out.printf("%3s", a[i]); 
                 
                    System.out.println(); 
                 
                    Test test = new Test(); 
                    test.bubbleSort(a); 
                 
                    System.out.print("排序后: "); 
                 
                    for (int i = 0; i < a.length; i++) 
                      System.out.printf("%3s", a[i]); 
                 
                    System.out.println(); 
                  } 
                 
                  public void bubbleSort(int[] a) { 
                    int len = a.length; 
                 
                    System.out.println("数组大小是:" + len); 
                 
                    boolean change = false; 
                    int temp; 
                    int count = 0; 
                 
                    for (int i = len; i > 1; i--) { 
                      for (int j = 0; j < i - 1; j++) { 
                        if (a[j + 1] < a[j]) { 
                          temp = a[j + 1]; 
                          a[j + 1] = a[j]; 
                          a[j] = temp; 
                          change = true; 
                          count++; 
                        } 
                 
                      } 
                      if (change) { 
                        System.out.print("第" + count + "趟交换: "); 
                        for (int k = 0; k < len; k++) 
                          System.out.print(a[k] + " "); 
                 
                        System.out.println(); 
                      } 
                    } 
                  } 
                } 
         
         
     *  
     * @param a 
     * @return 
     */  
    public static int[] bubbleSort(int[] a) {  
        int len = a.length;  
        for (int i = len - 1; i >= 1; i--) {  
            for (int j = 0; j <= i - 1; j++) {  
                if (a[j] > a[j + 1]) {  
                    int temp = a[j];  
                    a[j] = a[j + 1];  
                    a[j + 1] = temp;  
                }  
            }  
        }  
        return a;  
    }  
    /**************************************************** 
     *  
     *  
      
     选择排序的基本思想是：对待排序的记录序列进行n-1遍的处理. 
         第1遍处理是将L[1..n]中最小者与L[1]交换位置, 
         第2遍处理是将L[2..n]中最小者与L[2]交换位置，......， 
         第i遍处理是将L[i..n]中最小者与L[i]交换位置。 
    这样，经过i遍处理之后，前i个记录的位置就已经按从小到大的顺序排列好了。  
　　当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换位置，按从大到小的顺序进行排序处理。  
     *  
     * @param a 
     * @return 
     */  
    public static int[] selectionSort(int[] a) {  
        for (int i = 0; i < a.length; i++) {  
            for (int j = i + 1; j < a.length; j++) {  
                if (a[i] > a[j]) {  
                    int temp = a[i];  
                    a[i] = a[j];  
                    a[j] = temp;  
                }  
            }  
        }  
        return a;  
    }  
  
    public static int[] insertSort(int[] a) {  
        for (int i = 1; i < a.length; i++) {  
            for (int j = i; j > 0; j--) {  
                if (a[j] < a[j - 1]) {  
                    int temp = a[j];  
                    a[j] = a[j - 1];  
                    a[j - 1] = temp;  
                } else {  
                    break;  
                }  
            }  
        }  
        return a;  
    }  
  
}  
</strong></span>  
更多算法参考：http://blog.csdn.net/feixiaoxing/article/details/6993718
java 实现 冒泡排序、选择排序、插入排序。

java 实现冒泡排序、选择排序、插入排序。
