冒泡排序与选择排序的Java实现

冒泡排序与选择排序的Java实现

有8大基本排序算法，因为总是会碰到，所以打算进行一下总结，目前暂时一边理解一边用代码实现，先写了冒泡排序和选择排序，以后会补充其他排序算法。算法重在理解概念，形成一种解题思维，而实现的好坏则与个人的能力相关，所以学习算法，也要不断提高自己的编码能力。

冒泡排序

直接上自己写的代码，有关算法的理解之后补上。

import java.util.Arrays;

/**
 * @PackageName:
 * @ClassName: BubbleSort
 * @Description: 冒泡排序算法:每相邻两个元素进行比较，每次比较后，根据排序的要求交换位置。比如如果是从小到大排序，则将大的那个数放到后边，一轮比较下来就可以将最大的数放到数组的末端；然后对剩下的数重复相同的操作，获取第二大的数...直到所有元素排好序。
 * @author: 
 * @date: 2020-08-25 09:07
 */

public class BubbleSort {
    //常规的冒泡算法：使用嵌套循环，外循环代表确定所有元素位置所需进行的轮次，内循环表示每轮中所要进行的比较次数
    public static void bubbleSort(int[] array){
        for(int i=0;i<array.length-1;i++){
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }
    //冒泡排序的优化：如果某次排序比较中发现已经排好了序，显然就不需要再进行接下来的操作了
    public static void bubbleSortNew(int[] array){
        for(int i=0;i<array.length-1;i++){
            boolean flag=true;
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]<array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag=false;
                }
            }
            if(flag)
                break;
        }
    }
    public static void main(String[] args) {
        int a[]={1,553,13,34,63,32,667};
        System.out.println("排序前");
        System.out.println(Arrays.toString(a));
        
        bubbleSort(a);
        System.out.println("排序后");
        System.out.println(Arrays.toString(a));
        
        bubbleSortNew(a);
        System.out.println("排序后");
        System.out.println(Arrays.toString(a));
    }
}

输出结果：
排序前
[1, 553, 13, 34, 63, 32, 667]
排序后
[1, 13, 32, 34, 63, 553, 667]
排序后
[667, 553, 63, 34, 32, 13, 1]

选择排序

import java.util.Arrays;

/**
 * @PackageName: 
 * @ClassName: SelectSort
 * @Description: 选择排序算法：一次比较下来确定最大元素的所在位置，然后与最终排序好的应该所在位置进行交换，重复相同操作，直到所有元素排好序。
 * @author: 
 * @date: 2020-08-25 10:17
 */

public class SelectSort {
    //自己写的选择排序算法：外循环是确定所有元素位置的轮数，内循环是当前轮次所要比较的次数；每轮比较找到最大值所在元素并与未排序的最末尾的元素进行交换。
    public static void selectSort(int[] array){
        for(int i=0;i<array.length-1;i++){
            int index=array.length-1-i;
            for(int j=0;j<array.length-i-1;j++){
                if(array[j]>array[index]){
                    index=j;
                }
            }
            if(index!=array.length-1-i) {
                int temp = array[index];
                array[index] = array[array.length - 1 - i];
                array[array.length - 1 - i] = temp;
            }
        }
    }
    //选择排序：将比较得到的最值所在与数组前端排好序的下一个元素进行交换
    public static void selectSortN(int[] array){
        for(int i=0;i<array.length-1;i++){
            int index=i;
            for(int j=i+1;j<array.length;j++){
                if(array[j]>array[i])
                    index=j;
            }
            if(i!=index){
                int temp=array[index];
                array[index]=array[i];
                array[i]=temp;
            }
        }
    }
    public static void main(String[] args) {
        int[] a={1,334,667,23,7,34};
        System.out.println("排序前");
        System.out.println(Arrays.toString(a));

        selectSort(a);
        System.out.println("排序后");
        System.out.println(Arrays.toString(a));

        selectSortN(a);
        System.out.println("排序后");
        System.out.println(Arrays.toString(a));
    }
}

输出结果：
排序前
[1, 334, 667, 23, 7, 34]
排序后
[1, 7, 23, 34, 334, 667]
排序后
[667, 334, 34, 23, 7, 1]