算法（选择排序，冒泡排序，与插入排序与代码实现使用java实现）

算法代码实现（java版）

排序

常见的排序列表：

中文名称	英文名称	平均时间复杂度	最坏时间复杂度	最好时间复杂度	空间复杂度	稳定性
选择排序	Selection	n^2	n^2	n^2	1	不稳
冒泡排序	Bubble	n^2	n^2	n	1	稳
插入排序	Insertion	n^2	n^2	n	1	稳
堆排序	heap	nlog2n	nlog2n	nlog2n	1	不稳
希尔排序	Shell	n^1.3	n^2	n	1	不稳
归并排序	Merge	nlog2n	nlog2n	nlog2n	n	稳
快速排序	Quick	nlog2n	n^2	nlog2n	log2n	不稳
桶排序	Bucket	n+k	n^2	n	n+k	稳
计数排序	Counting	n+k	n+k	n+k	n+k	稳
基数排序	Radix	n*k	n*k	n*k	n+k	稳

最重要的：插入排序，堆排序，归并排序，快速排序。

如何写算法程序：

1.由简单到复杂：验证一步走一步，多打印中间结果。

2.先局部后整体：没思路时先细分。

3.先粗糙后精细：变量名更改，语句合并，边界处理。

代码实现我们这里会使用java语言。

选择排序的代码实现（Selection）：

第一次我们会以一个非常简单的方式带你入门。

第一步：自然是创建一个类我们把他取名为 MySelectionSort 

public class MySelectionSort{

    public static void main (String[] args){

//定义一个数组有10个数

        int arr[] = {7,8,9,1,2,5,6,3,4,0};

//打印出数组

        for(int i=0;i<arr.length;i++){

            System.out.print(arr[i] + " ");

        }

    }

}

那么你打印出的结果自然是：7 8 9 1 2 5 6 3 4 0

第二步：我们在原来的基础上找到其中最小的数，实现方法就是先假定第一个数为最小的数，然后一 一与后面的数字进行比较，如果比第一个数大则继续往后比较

如果比第一个数小则俩者互换。

public class MySelectionSort{

    public static void main (String[] args){

//定义一个数组有10个数

        int arr[] = {7,8,9,1,2,5,6,3,4,0};

//假设第一个数为最小数

        int minPros = 0;

        for(int j = 1;j<arr.length;j++){

            if(arr[minPros]>arr[j]){

              minPros = j;

            }

        }

        System.out.println(arr[minPros]);

//打印出数组

                   int temp = arr[0];

            arr[0] = arr[minPros];

            arr[minPros] = temp;

        for(int i=0;i<arr.length;i++){

            System.out.print(arr[i] + " ");

        }

    }

}

打印结果为：

0

0 8 9 1 2 5 6 3 4 7

既然可以知道最小的数为0

第三步：那么我们想要把数组进行选择排序，可知道，只需要把每一次的输出的最小的数打印出来即可，即在外面套一层循环

public class MySelectionSort{

    public static void main (String[] args){

//定义一个数组有10个数

        int arr[] = {7,8,9,1,2,5,6,3,4,0};

//假设第一个数为最小数

        for (int i=0;i< arr.length;i++){

            int minPros = i;

            for(int j =i+1;j<arr.length;j++){

                if(arr[minPros]>arr[j]) {

                    minPros = j;

                }

            }

            int temp = arr[i];

            arr[i] = arr[minPros];

            arr[minPros] = temp;

        }

            for(int i=0;i<arr.length;i++){

            System.out.print(arr[i] + " ");

            }

    }

}

输出结果为：0 1 2 3 4 5 6 7 8 9

冒泡排序（Bubble）：

基本概念：下面我们定义一个数组，如：

9

7

5

4

6

8

3

0

2

1

对它进行冒泡排序其实非常简单，接下来让我们简单的来实现它一下。

第一步：

我们可以从左边或者右边开始都可以，大数往下沉的就是左边开始，小数往下沉的就是右边开始。

我们先把9与7进行对比会发现9>7。所以俩个数进行交换。这时9来到了1的位置，然后9与5对比

9>5。所以俩者交换。同理依次进行交换直到最后。得到数组为：7 5 4 6 8 3 0 2 1 9

这里需要特别注意的是此操作是你可以想象一把天平从左往右，俩俩进行比较而不是第一个数与所有进行比较。

接下来我们进行代码实现：

public class MyBubbleSort {

    public static void main(String[] args) {

        int[] arr={9,7,5,4,6,8,3,0,2,1};

            for (int i = 0; i < 9; i++) {

                if (arr[i] > arr[i + 1]) {

                    int temp = arr[i];

                    arr[i] = arr[i+1];

                    arr[i+1] = temp;

                }

            }

        

        for (int i=0;i<arr.length;i++){

            System.out.print(arr[i]);

        }

    }

}

输出结果：7546830219

第二步:我们将第一轮排序好后，接下来将会继续进行一轮冒泡排序：

5 7 4 6 8 3 0 2 1 9

5 4 7 6 8 3 0 2 1 9

5 4 6 7 8 3 0 2 1 9

5 4 6 7 8 3 0 2 1 9

5 4 6 7 3 8 0 2 1 9

5 4 6 7 3 0 8 2 1 9

5 4 6 7 3 0 2 8 1 9

5 4 6 7 3 0 2 1 8 9

得到以上过程，由此你可以发现冒泡排序的过程就好像一把天平，左右一次只能放一个数然后进行对比，把当左天平小于右天平时，

俩者进行对调，反之不需要调整，然后天平继续往右移动以此类推一直到最右时，在把天平移动回最左边，继续排序，以此类推。

那么我们要实现此代码并不难只需要在for循环的外层在套一层for(int j=arr.length-1;j>0;j--)，这里需要注意的是j的开始定义为arr.length-1，而不是arr.length。

且i<9，而不是i<10，否则会出现长度的报错。

public class MyBubbleSort {

    public static void main(String[] args) {

        int[] arr={9,7,5,4,6,8,3,0,2,1};

        for (int j=arr.length-1;j>0;j--){

            for (int i = 0; i < 9; i++) {

                if (arr[i] > arr[i + 1]) {

                    int temp = arr[i];

                    arr[i] = arr[i+1];

                    arr[i+1] = temp;

                }

            }

        }

        for (int i=0;i<arr.length;i++){

            System.out.print(arr[i]);

        }

    }

}

输出结果：0123456789

插入排序（Insertion）:

对于基本有序的数组最好用，且是稳定的。

基本概念：

我们来介绍一下插入排序的基本概念。假如我们有一段数据如下：

9

6

1

3

5

假如我们对它进行插入排序。首先我们需要确定一个已排好的位置，假设我们先确定好9的位置，然后在1的为即6与数字9进行比较。

如果左边的数6，小于已经确定好位置的数字9，那么俩数对调，得到数组：

6

9

1

3

5

然后6已是左边最小的数所以第一轮排序结束，接着我们在左边的第二个数1，与已排好的数据6,9中的9先进行比较，同理1<9，所以

对换，然后在用1往左走与6比较，1<6，所以对换。得到数组如下：

1

6

9

3

5

同理像上述操作一样，继续进行排序。最后即可得到排好的数组：

1

3

5

6

9

接下来我们来看一下代码实现：

public class Insertion {

    public static void main(String[] args) {

        int[] a = {9,7,5,3,2,4,1,0,6,8};

        sort(a);

        print(a);

    }

    static void sort (int[] a){

        for(int i=1;i<a.length;i++){

            for(int j=i;j>0;j--){

               if(a[j] < a[j-1]){

                  swap(a,j,j-1);

               }

            }

        }

    }

    static void swap (int[] a,int i,int j){

        int temp = a[i];

        a[i] = a[j];

        a[j] = temp;

    }

    static void print (int[] arr){

        for(int i=0;i<arr.length;i++){

            System.out.print(arr[i]);

        }

        

    }

}

输出结果：0123456789

其他等下次再写吧。感谢！

---