数组（冒泡排序，选择排序，插入排序）

数组的定义：数组是相同类型数据的有序的集合。

数组会在内存中开辟一块连续的空间，每一个空间相当于之前的一个变量，称为数组元素。

数组元素的表示：数组名【数组下标/索引】。

注意：数组的下标/索引从0开始，最大索引的算法是【数组长度减1】。

每个数组的元素都有默认值。

数组元素是有序的，但并不是大小的顺序，而是索引的顺序。

数组中可以存放基本数据类型，也可以存放引用数据类型。但是对于一个数组来说，数组的类型是固定的，只能是其中一种。

数组的长度一般用length来表示。

数组的长度是固定的，一经定义，不能再发生变化。

数组的冒泡排序：

public class TestBubbleSort {

            public static void sort(int[] a) {

                        int temp = 0;                  

                        // 外层循环，它决定一共走几趟

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

                                    //内层循环，它决定每趟走一次

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

                                                //如果后一个大于前一个

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

                                                            //换位

                                                            temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;

                                                }

                                    }

            }         

           

public static void sort2(int[] a) {

                        int temp = 0;

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

                                    //通过符号位可以减少无谓的比较，如果已经有序了，就退出循环

                                    int flag = 0;

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

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

                                                            temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;

                                                            flag = 1;

                                                }

                                    }

                                    if(flag == 0){        break;}                             

                        }

            }

}

数组的选择排序：

public class TestSelectSort {

            public static void sort(int arr[]) {

                        int temp = 0;

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

                                    // 认为目前的数就是最小的, 记录最小数的下标

                                    int minIndex = i;

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

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

                                                            // 修改最小值的下标

                                                            minIndex = j;

                                                }

                                    }

                                    // 当退出for就找到这次的最小值

                                    if (i != minIndex) {

                                                temp = arr[i];

                                                arr[i] = arr[minIndex];

                                                arr[minIndex] = temp;

                                    }

                        }

            }

}

数组的插入排序：

public class TestInsertSort {

            public static void sort(int arr[]) {

                        int i, j;

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

                                    int temp = arr[i];

                                    for (j = i; j > 0 && temp < arr[j - 1]; j--) {

                                                arr[j] = arr[j - 1];

                                    }

                                    arr[j] = temp;

                        }

            }

}