数据结构复习之排序算法复习（冒泡and插入）Java版

排序算法复习

一、冒泡排序

冒泡排序：重复遍历要排序的数列，每次比较两个元素，如果位置错误就将其交换。因为像泡泡浮出水面，故而名曰冒泡排序。

步骤：

• 每次从数列底部选择一个元素，与其上一个元素进行比较。
• 内层循环控制将一个元素排序
• 外层循环控制总共需要排序元素总数

优化：

• 在排序中中途可能即已经有序，此时不会交换元素，但是还有元素仍未被排序，所以会进行一些无意义的循环
• 当有序时不交换元素，设置标志位，如果已经有序则停止循环

代码如下：

package SortTest;

import java.util.Random;

public class BubblingSortTest {
    public static void main(String[] args) {
        BubblingSortTest bubblingSortTest = new BubblingSortTest();
        int[] buildelement = bubblingSortTest.buildelement();
        //未优化
        int[] bullingsorted = bubblingSortTest.bullingsorted(buildelement);
        //已优化
        //int[] bullingsorted = bubblingSortTest.optimizationSorted();
        bubblingSortTest.printSort(bullingsorted);
    }
    //建立长度为10的测试数组
    public int[] buildelement(){
        int[] element = new int[10];
        Random random = new Random();
        for (int i=0;i<10;i++){
            //生成0-10之间的随机数
            element[i] = random.nextInt(10);
        }
        return element;
    }
    //冒泡排序
    public int[] bullingsorted(int[] element){
        int temp=0;
        for(int i=0;i<element.length;i++){
            for(int j=0;j<element.length;j++){
                if(element[j]<element[j+1]){
                    temp = element[j];
                    element[j] = element[j+1];
                    element[j+1] = temp;
                }
            }
        }
        return element;
    }
    //冒泡排序优化
    public int[] optimizationSorted(int[] element){
        int temp=0;
        boolean flag = true;
        for(int i=0;i<element.length;i++){
            for(int j=0;j<element.length;j++){
                if(element[j]<element[j+1]){
                    temp = element[j];
                    element[j] = element[j+1];
                    element[j+1] = temp;
                    flag = false;
                }
            }
            if(flag){
                break;
            }
        }
        return element;
    }
    //结果输出
    public void printSort(int[] element){
        for (int i=0;i<element.length;i++){
            System.out.print(element[i]+" ");
        }
    }
}

冒泡排序总结：

• 时间复杂度：O(n^2)、最好情况时间复杂度O(n)、最坏时间复杂度O(n2)
• 空间复杂度：O(1) 冒泡排序是一种原地排序算法
• 稳定性：稳定（当排序中有值相等的元素，在排序中不交换其位置则为稳定排序算法）

二、插入排序

插入排序：将数列分为两个区间，已排序区间和未排序区间。初始已排序区间有一个元素（因为一个元素一定是有序的）。插入算法核心就是将未排序区间中提取元素放入已排序区间的适当位置中，以保证已排序区间始终有序。最终未排序区间元素全部移动到已排序区间，算法结束。

步骤：

• 从第一个元素开始，认为该元素已经被排序
• 取出下一个元素，和已排序区元素进行比较
• 如果该未排序元素小于已排序元素，则将该元素向前移动
• 重复三步骤，直到找到合适位置
• 取下一元素重复以上步骤

代码如下：

package SortTest;

import java.util.Random;

public class InsertSortTest {
    public static void main(String[] args) {
        InsertSortTest insertSortTest = new InsertSortTest();
        int[] buildelement = insertSortTest.buildelement();
        int[] insertSorted = insertSortTest.insertSorted(buildelement);
        insertSortTest.printSort(insertSorted);
    }
    //建立长度为10的测试数组
    public int[] buildelement(){
        int[] element = new int[10];
        Random random = new Random();
        for (int i=0;i<10;i++){
            //生成0-10之间的随机数
            element[i] = random.nextInt(10);
        }
        return element;
    }
    //插入排序算法
    public int[] insertSorted(int[] element){
        if (element.length <= 1){
            return element;
        }
        for (int i=1;i<element.length;i++){
            int next = element[i];
            //有序区的最后一个元素下标，每循环一次有序区大小增加一
            int preIndex = i - 1;
            while (preIndex >= 0 && element[preIndex] > next){
                //有序区元素向后移动一位
                element[preIndex+1] = element[preIndex];
                //preIndex--是为了让该元素与下一个有序区元素比较
                preIndex--;
            }
            //如果找到位置后 由于上面的程序特性会多进行一次preIndex--，所以这里要+1
            element[preIndex+1] = next;
        }
        return element;
    }
    //结果输出
    public void printSort(int[] element){
        for (int i=0;i<element.length;i++){
            System.out.print(element[i]+" ");
        }
    }
}

图示：

插入排序总结：

• 时间复杂度：O(n^{2)、最好时间复杂度O(n)、最坏时间复杂度O(n}2)

• 空间复杂度：O(1)

• 稳定性：稳定

后续排序算法会逐步更新。
新人起步，分享所学。