数据结构与算法--------Java实现（第四章 排序算法 上）

一、排序算法导图

二.算法实现

冒泡排序

1.算法简介：

• 冒泡排序是所有排序算法中最简单、最基本的一种。冒泡排序法的思路就是交换排序，通过相邻数据的交换来达到排序的目的。

2.排序流程：

• 对数组的各个数据，依次比较相邻的元素的大小；
• 如果前面的数大于后面的数，就交换这两个数据，经过第一轮的多次比较后，便可把最小的数据排好；
• 再用同样的方法把剩下的数据逐个进行比较，最后便可以按照从小到大的顺序排好数组各数据的顺序。

3.优劣分析

• 冒泡排序在对N个数据进行排序时，无论原数据有多无序，都需要进行N-1 步的中间排序。
• 冒泡排序算法思路简单，但是缺点就是执行步骤有点长，效率不高。

4.算法优化:

• 在每次中间排序后，比较一下数据是否已经按照顺序排列完成。如果已经完成则退出排序，否则继续冒泡排序。对于数据较规律的可以加快排序速度。

5.代码演示：

import java.util.Scanner;

public class BubbleSort {
    static final int MAXLEN = 20;   //指定数组的最大长度

    public static void main(String[] args) {
        int[] waitSort = new int[MAXLEN];
        Scanner input = new Scanner(System.in);
        System.out.println("冒泡排序算法演示");
        System.out.println("请输入待排序数据的个数（<20）：");
        int num = input.nextInt();
        System.out.println("请输入待排序数据：");
        for (int i = 0; i < num; i++) {
            waitSort[i] = input.nextInt();
        }
        sortArr(waitSort, num);     //调用冒泡排序算法进行排序
        System.out.print("最终排序结果为：");
        for (int i = 0; i < num; i++) {      //打印排序后的结果
            System.out.print(+waitSort[i] + " ");
        }
    }

    //冒泡排序  参数一：待排序数组      参数二：元素的个数
    private static void sortArr(int[] waitSort, int num) {
        int temp;
        int start;      //起始位置
        int end = num - 1;    //结束的位置
        for (int i = 0; i < end; i++) {     //总遍历轮数 = num - 1 次
            start = -1;
            for (int j = 0; j < end - i; j++) {     //每轮比较次数 = 比前一轮少一次
                start = start + 1;
                if (waitSort[start] > waitSort[start + 1]) {      //如果前一个数大于后一个数
                    temp = waitSort[start + 1];
                    waitSort[start + 1] = waitSort[start];   //交换他们的位置
                    waitSort[start] = temp;
                }
            }
            System.out.print("第" + (i + 1) + "轮排序的结果：");
            for (int k = 0; k < num; k++) {
                System.out.print(waitSort[k] + " ");
            }
            System.out.println();
        }
    }
}

选择排序

1.算法简介：

• 选择排序也是比较简单的排序算法，思路比较直观。选择排序在每一步中选取最小值来重新排列，从而达到排序目的。

2.排序流程：

• 首先从原始数组中选择最小的1个数据，将其和位于第一位置的数据交换；
• 接着从剩下的n-1个数据中选择次小的1个数据，将其和第二个位置的数据交换；
• 然后，这样不断重复，直到最后两个数据完成交换。至此，就完成了对原始数组的排序。

3.算法优劣：

• 选择排序算法在对N个数据进行排序时，无论原数据有无顺序，都需要进行N-1步的中间排序。思路简单，但执行步骤较长，效率不高。

4.代码演示：

import java.util.Scanner;

public class SelectSort {
    static final int MAXLEN = 20;   //指定数组的最大长度

    public static void main(String[] args) {
        int[] waitSort = new int[MAXLEN];
        Scanner input = new Scanner(System.in);
        System.out.println("选择排序算法演示");
        System.out.println("请输入待排序数据的个数（<20）：");
        int num = input.nextInt();
        System.out.println("请输入待排序数据：");
        for (int i = 0; i < num; i++) {
            waitSort[i] = input.nextInt();
        }
        sortArr(waitSort, num);     //调用选择排序算法进行排序
        System.out.print("最终排序结果为：");
        for (int i = 0; i < num; i++) {      //打印排序后的结果
            System.out.print(+waitSort[i] + " ");
        }
    }
    //选择排序 参数一：待排序的数据   参数二：数据的个数
    private static void sortArr(int[] waitSort, int num) {
        int min;    //每轮最小数据
        for (int i = 0; i < num - 1; i++) {      //找出每一轮中最小的数据
            for (int j = 1; j < num - i; j++) {     //找出当前轮中最小的数
                if (waitSort[i] > waitSort[i + j]) {  //如果后面的数据中比当前比较的数字小，则交换
                    min = waitSort[i + j];
                    waitSort[i + j] = waitSort[i];
                    waitSort[i] = min;
                }
                System.out.print("内" + j + "轮数据为");
                for (int k = 0; k < num; k++) {
                    System.out.print(waitSort[k] + " ");
                }
                System.out.println();
            }
        }
    }
}

插入排序

1.算法简介：

• 插入排序通过对未排序的数据执行逐个插入至合适的位置而完成排序工作。算法思路简单，使用较多，类似于打牌时整理牌。

2.排序流程：

• 首先对数组的前两个数据进行从小到大的排序；
• 接着将第3个数据与排好序的两个数据进行比较，将第3个插入到合适的位置；
• 然后，将第4个数据插入到已排好序的前三个数据中。
• 不断重复上述过程，直到把最后一个数据插入到合适的位置。31

3.算法优劣：

• 选择排序算法在对N个数据进行排序时，无论原数据有无顺序，都需要进行N-1步的中间排序。思路简单，在数据已有一定顺序的情况下，排序效果较好。但数据无规则时，需要移动大量数据，效果也就变差了。

4.代码演示：

public class InsertSort2 {
    static final int SIZE = 10;

    public static void main(String[] args) {
        int[] arr = new int[SIZE];
        int i;
        for (i = 0; i < SIZE; i++) {
            arr[i] = (int) (100 + Math.random() * (100 + 1));  //初始化数组
        }
        System.out.println("排序前的数组为:");
        for (i = 0; i < SIZE; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        insertionSort(arr);     //排序操作
        System.out.print("排序后的数组为:");
        for (i = 0; i < SIZE; i++) {
            System.out.print(arr[i] + " ");  //输出排序后的数组
        }
    }

    static void insertionSort(int[] a) {    //插入排序
        int i, j, t, h;
        for (i = 1; i < a.length; i++) {
            t = a[i];
            j = i - 1;
            //要插入的数如果小于它前面的数,则比他大的数据统统后移
            while (j >= 0 && t < a[j]) {       
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = t;
            System.out.print("第" + i + "步的排序结果:");//输出每步排序的结果
            for (h = 0; h < a.length; h++) {
                System.out.print(" " + a[h]);
            }
            System.out.println();
        }
    }
}

github地址：https://github.com/flakkaqi/DataStructure_and_Algorithms.git