2022-07-15 第10组 蒋萍 数组的查找、排序和反转

目录

• 数据结构
  • 1、数组
    • 1.1 查找
      • 1.1.1 二分法
    • 1.2、排序：
      • 1.2.1 冒泡排序
      • 1.2.2 插入排序
      • 1.2.3 选择排序
    • 1.3、数组的反转
    • 1.4 数组的扩容

写在前面
“长春也很美”
“有多美呢？”
“长春那样美”

今天开始接触算法题，能看懂，思路感觉也不难，但代码要自己敲出来，怕是搞不定，u呜呜呜，要一直努力呀~~

数据结构

1、数组：最基本的数据结构（数组就是一张线性表：数据元素间是一对一对的关系，除了第一个和最后一个之外，其余元素都是首尾连接的）

2、链表：双向、单向；

3、树：开枝散叶

4、图 （太难！）

1、数组

1.1 查找

1.1.1 二分法

• 使用条件：有序数组，无重复元素

• 找出一个数在数组中是否存在

  可跳转到我的这篇文：

https://www.cnblogs.com/fulfill/p/16482313.html

1.2、排序：

1、冒泡 2、快排 3、插入 4、选择

5、希尔 6、堆排 7、归并 8、桶排

1.2.1 冒泡排序

 /* 冒泡排序 */
        // 从小到大：
        /*思路分析：
        *       先拿第一个数和后面的数一一比较大小；
        *       第一轮比较完成后，最大值已归位，
        *       第二轮比较得第二大的数，
        *       一直做下去
        *
        * */

        /*冒泡排序需要两层循环嵌套：for
        * 外层for循环控制需要各个数之间要比较得轮数
        * 内层for循环控制每个数的比较
        * */
        int[] arr = new int[]{1,23,5,675,57};
        // 比较轮数是数组长度-1
        for (int i = 0; i < arr.length - 1; i++) {
            // 数组中数的比较
            for (int j = 0; j < arr.length - 1 - i; j++) { // 注意越界问题
                if (arr[j] > arr[j+1]){ // 从大到小排序的话这就变小于号
                    // 前面的数大于它的后一个，换位
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
            System.out.print("第" + (i + 1) + "轮的比较结果为：");
            for (int j : arr) {
                System.out.print(j + "、");
            }
            System.out.println( );
        }
        
        // 简便操作:（只能从小到大排~~）
       // Arrays.sort(arr);
        

1.2.2 插入排序

       /* 
        插入排序：
                    假设数组是从小到大排序的，
                    拿着第一个数（参照数）和后面的比较，
                    发现比参照数小的，就往这个参照数前插入，其余的往后移（注意不要覆盖）
        */

        int[] arr = new int[]{1, 25, 48, 12, 10, -8, 127,56};
        // 参照数,和它前一个数你家里
        int current;
        for (int i = 0; i < arr.length - 1; i++) {
            current = arr[i + 1];
            // 上一个数的下标
            int preIndex = i;
            // 上一个数的下标不能出现负数,确保在数组范围内比较；当前的数比前一个数小，当前数才能往前移位
            while (preIndex >= 0 && current < arr[preIndex]){
                // 前一个数往后移一位，
                arr[preIndex + 1] = arr[preIndex];
                // 后面的数怎么往前移呢？？
                preIndex--;// preIndex=-1时，循环终止，此时，这个数就是在第一位，
            }
            arr[preIndex + 1] = current;
        }
/*
* 第一轮：
*       i = 0; current = arr[1]=25,int preIndex = 0;
*       while( 0>=0 && 25 < arr[0]){}不成立，while循环不动
*       arr[0+1] = current
* 第二轮：
*       i = 1;current = arr[2]=48,int preIndex = 1;
*       while(1 >=0 && 48 < arr[1]){}不成立，while循环不动
*       arr[1+1] = current
*           …………………………
* * */
        

1.2.3 选择排序

  /* 选择排序 ：
        * 最小的往前放；
        * 或者把最大的放在最后，方法同上面的类似
        * */

/* 1、第一轮，找到整个数组中最小的值，然后把这个最小的值和第一位换位；
            假设第一个数（下标为0）就是最小的数，然后让这个数和每个数都比较
            当发现比它小的数（下标为x），然后用这个下标为x的数继续比较下去
   2、第二轮找到第二小的那个数，和第2个位置的数换位；
   3、……一直做下去
   
        》该走第几轮，定义的 minIndex就是几，就是从哪开始
        
 */
int[] arr = new int[]{1,24,5,688,98,2,-23};


// 外层控制轮数
// 注意：这里arr.length后面不能减 1
for (int i = 0; i < arr.length; i++) {
    // 最小数的下标
    int minIndex = i;
    for (int i1 = i + 1; i1 < arr.length; i1++) {
        // i1 = i + 1 ???  i = 1 的时候已经不用比较前一位了，直接从 i+1 开始即可
        //    》该走第几轮，定义的 minIndex就是几，就是从哪开始
        if (arr[minIndex] > arr[i1]){
            // 换位
            minIndex = i1;
        }
    }

    int tmp = arr[minIndex];
    arr[minIndex] = arr[i];
    arr[i] = tmp;
    System.out.println("第" + (i+1) + "次比较结果为：");
    for (int i1 : arr) {
        System.out.print(i1 + "、");
    }
    System.out.println( );
}

1.3、数组的反转

        /*
        * 创建一个等长的数组；
        * 把当前数组的每一个元素倒着添加到新数组中
        * 新数组赋值给老数组
        *
        * */

        int[] arr = new int[]{1,2,4,6,5,76,11};
        
 /*       int[] result = new int[arr.length];

        for (int i = arr.length; i >= 0; i--) {
            result[i] = arr[arr.length - 1 - i];
        }
        arr = result;

        for (int i : arr) {
            System.out.println(i);
        }
*/
// 第2种方式：
        for (int i = 0; i < arr.length / 2; i++) {
            int tmp = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = arr[i];
            arr[i] = tmp;
        }   

1.4 数组的扩容

/* 数组的扩容 */
        int[] nums = new int[]{3,4,6};
        // 临时数组
        int[] tmp = new int[6];
        for (int i = 0; i < nums.length; i++) {
            tmp[i] = nums[i];
        }
        nums = tmp;
        System.out.println(Arrays.toString(nums));