java5 - 数组与排序算法

数组是什么？

---

一、一维数组

1 声明与定义的区别

一般的情况下我们常常这样叙述，
把建立空间的声明称之为"定义",
而把不需要建立存储空间称之为"声明".

很明显我们在这里指的声明是范围比较窄的，
也就是说非定义性质的声明。

    // 1、声明
    int a[];
    int[] b;

    // 2、定义
    a = new int[5];
    b = new int[5]; 
    
    // 3、赋值
    a[0] = 1;
    a[1] = 2;
    a[2] = 3;
    a[3] = 4;
    a[4] = 5;

    // 4、定义
    int[] a = new int[10];
    int a[] = new int[10];
    
    // 5、定义并初始化
    int[] a = {1,2,3,4};
    int[] a = new int[]{1,2,3,4};

1.2 运用

1. 数组名表示什么？
2. arr[0]表示什么？
   
3. 怎么获取数组长度？
4. 如何使用数组下标取值？
5. 如何输出数组中所有的元素？
6. 如何给数组中所有元素求和？
7. 如何找出数组中最大值，最小值？
8. 如何判断数组中是否包含某一个值？
9. 如何去除数组中的重复元素？
10. 如何求两个数组元素的交集与并集？
11. 如何判断两个数组是包含的元素值都相同？

练习：

一个班有10个同学的数学成绩需要记录，
要计算班级
总成绩，
平均成绩，
最高分，
最低分，
及格人数等数据。

二、二维数组

2.1 二维数组其实就是矩阵。

2.2 声明、定义与初始化

    // 声明
    int a[][];
    int[][] b;
    
    // 第一次给一个声明的变量赋值叫做初始化
    a = new int[][]{{1,1,1},{2,2,2}}; 
    
    // 定义
    int c[][] = {{1,1,1},{2,2,2}};
    
    int[][] d = {{1,1,1},{2,2,2}};

2.3 运用

练习1

//  某校幼儿园有3个班，每个班有5个人，计算各班平均年龄？计算全园平均年龄？计算总人数？

    int students[][] = { { 3, 6, 4, 5, 4 }, { 2, 3, 5, 3, 2 }, { 3, 4, 6, 2, 4 } };
    int[][] students = { { 3, 6, 4, 5, 4 }, { 2, 3, 5, 3, 2 }, { 3, 4, 6, 2, 4 } };

练习2

1. 打印出杨辉三角？

---

三、数组排序

3.1、选择排序

    int[] array1 = { 2, 3, 1, 5, 4 };
    // 控制遍历的次数
    for (int i = 0; i < array1.length - 1; i++) {
        // int min = array1[i]; // 默认最小值
        int minIndex = i; // 记录最小值的下标
        // 找出最小值
        for (int j = i + 1; j < array1.length; j++) {
            if (array1[j] < array1[minIndex]) {
                minIndex = j;
            }
        }
        // 如果最小值不在最前面，和最前面做交换
        if (minIndex != i) {
            int temp = array1[i];
            array1[i] = array1[minIndex];
            array1[minIndex] = temp;
        }
    }
    // 输出
    System.out.println("选择排序之后：");
    for (int i = 0; i < array1.length; i++) {
        System.out.println("array1[" + i + "] = " + array1[i]);
    }

3.2、冒泡排序

    int array3[] = { 1, 3, 4, 6, 2, 11, 19, 2, 7, 0 };
    // 控制遍历次数
    for (int i = 0; i < array3.length - 1; i++) {
        // 控制比较交换
        for (int j = 0; j < array3.length - i - 1; j++) {
            // 控制交换条件
            if (array3[j] > array3[j + 1]) {
                int temp = array3[j];
                array3[j] = array3[j + 1];
                array3[j + 1] = temp;
            }
            System.out.print("array3 第" + (i + 1) + "次冒泡,第" + (j + 1) + "比较结束：");
            for (int i1 = 0; i1 < array3.length; i1++) {
                System.out.print("," + array3[i1]);
            }
            System.out.println("");
        }
        System.out.print("array3 第" + (i + 1) + "次冒泡结束：");
        for (int i1 = 0; i1 < array3.length; i1++) {
            System.out.print("," + array3[i1]);
        }
        System.out.println("");
    }
    System.out.println("array3 冒泡排序之后：");
    for (int i = 0; i < array3.length; i++) {
        System.out.println("array3[" + i + "] = " + array3[i]);
    }

3.3、直接插入排序

    int array6[] = { 3, 4, 2, 1, 5, 6, 9, 8, 7, 0 };
    /**
     * 2 2,3,4
     */
    for (int i = 1; i < array6.length; i++) {
        int j = i; // 2, i = 2 ; j = 2
        int temp = array6[i];
        while (j > 0 && temp < array6[j - 1]) {
            array6[j] = array6[j - 1]; // array6[2] = array6[1];
            j--;
        }
        System.out.println("第" + i + "次移动后：");
        for (int i1 = 0; i1 < array6.length; i1++) {
            System.out.print("," + array6[i1]);
        }
        System.out.println();
        array6[j] = temp;
    }
    System.out.println("array6 直接插入排序之后：");
    for (int i = 0; i < array6.length; i++) {
        System.out.println("array6[" + i + "] = " + array6[i]);
    }

3.4、阶乘

    /**
     * 1！   = 1 
     * 2！   = 2 x 1             = 2 x 1！ 
     * 3!   = 3 x 2 x 1         = 3 x 2! 
     * 4!   = 4 x 3 x 2 x 1     = 4 x 3! 
     * ......
     */ static int Factorial(int n) {
        // return n*(n-1)!
        if (n < 1) {
            return 0;
        }
        if (n == 1) {
            return 1;
        } else {
            return n * Factorial(n - 1);
        }
    }

3.5、归并排序

    static void MSort(int[] arr, int left, int right) {
        int mid = (left + right) / 2;
        if (left < right) {
            // 递归拆分左边
            MSort(arr, left, mid);  
            // 递归拆分右边
            MSort(arr, mid + 1, right); 
            // 将拆分的有序数组排序
            Merge(arr, left, mid, right);
        }
    }

    static void Merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int low1 = left; // 左边数组的起始位置
        int low2 = mid + 1; // 右边数组的起始位置
        int index = 0;
        // 比较拆分的两个子数组，依次取最小值，放入新数组
        while (low1 <= mid && low2 <= right) {
            if (arr[low1] <= arr[low2]) {
                temp[index++] = arr[low1++];
            } else {
                temp[index++] = arr[low2++];
            }
        }
        // 把左边剩余的装进新数组
        while (low1 <= mid) {
            temp[index++] = arr[low1++];
        }
        // 把右边剩余的装进新数组
        while (low2 <= right) {
            temp[index++] = arr[low2++];
        }
        //把新数组里面的有序元素数，装进原数组
        for (int i = 0; i < temp.length; i++) {
            arr[i + left] = temp[i];
        }
    }

转载于:https://www.cnblogs.com/markbin/p/6515390.html