2022-7-15 第七组---数组

初浔云深

已于 2022-08-14 14:39:03 修改

阅读量255

点赞数

文章标签：大数据 java 算法数据结构

于 2022-07-16 00:00:42 首次发布

本文链接：https://blog.csdn.net/qq_49036727/article/details/125796873

版权

今日重点:

目录

一、数据结构（大概去了解）

二、数组中的算法应用

（1）查找算法

（2）排序算法

三、数组的反转

四、数组的扩容

写程序的思路小tip：整理好思路再敲代码！
1.先完成需要要求的功能
2.根据程序运行的结果进行优化处理
3.代码重构
4.提升效率（研究算法）

一、数据结构（大概去了解）

数据结构是指数据在计算机内存空间中或磁盘中的组织形式，算法是完成特定任务的过程，数据类型是指一组值和一组对这些值得操作的集合。

Java有常见的八种数据结构

二、数组中的算法应用

数组是最基本的数据结构，是一张线性表（数据元素之间是一对一），连续都空间存储相同类型的数据---除了第一个和最后一个元素，其余的元素都是首尾连接。

（1）查找算法

①线性查找

要求：
找出一个数在数组中的位置
在数组中是否存在，如果存在，返回下标，如果不存在，返回-1
如果找到了，则把下标i保存起来，显示的你要找的数是xx，在目标数组中的下标是xxx
如果没找到，则显示你要找的数是xx，在目标数组中是不存在的。

package com.jr.morning;

import java.util.Scanner;

// 查找算法--线性查找：简单，便于理解
public class y1 {
    public static void main(String[] args) {
/*        要求：
       找出一个数在数组中的位置
       在数组中是否存在，如果存在，返回下标，如果不存在，返回-1
       如果找到了，则把下标i保存起来，显示的你要找的数是xx，在目标数组中的下标是xxx
       如果没找到，则显示你要找的数是xx，在目标数组中是不存在的。

*/
         int [] arr =new int[]{23,34,45,78,99,68,85};
         Scanner sc =new Scanner(System.in);
         System.out.println("请输入一个数：");
        int num = sc.nextInt();
        //定义一个布尔标志
        boolean flag =false;//此处可以注销
        int index=-1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                flag=true;//此处可以注销
                index =i;
                break;
              }

        }
        if (flag){//注销上面两行代码之后，此处改成if(index != -1){}
            System.out.println("你要找的数是："+ num+",在目标数组中的下标是："+index);
        } else {
           System.out.println("你要找的数是："+ num+",在目标数组中不存在："+index);
        }

    }
}

1. Boolean flag= true / false ;
2.if(flag)等价于if(flag=true)
3.if(f1ag)等价于if(flag-=true)
if(无论什么样子的booleanQ语句==true) 无论什么样式的boolean语句，仅当只有这个语句等于true时,才能执行if下面的{}中的语句，这个语句等于false时,执行的是else下面的(}中的语句.

②折半查找（二分法查找）

package com.jr.morning;

import java.util.Scanner;

//查找算法--折半查找（二分法查找）：比线性查找更节省时间
//如果要使用二分法查找找数字，前提是这个数组必须有顺序
public class y2 {
    public static void main(String[] args) {
        int [] arr = new int[]{1,2,3,4,5,6,7};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查找的数字：");
        int target = sc.nextInt();

        // 最左边的下标
        int left = 0;
        // 最右边的下标
        int right =  arr.length - 1;
        if(target < arr[left] || target > arr[right]){
            System.out.println(target + "在目标数组中不存在！");
        }else {
            // 用来保存找到的下标的值
            int res = -1;
            while(left <= right) {
                // 找出中间的下标
                int middle = (left + right) / 2;
                if(arr[middle] == target) {
                    // 中间的数恰巧就是我们要找的数
                    res = middle;
//                    left = arr.length;
                    break;
                }else if(arr[middle] > target){
                    // 说明我们要找的数在数组的前半区
                    /*
                        如果在前半区
                        维护left和right
                        left是不需要动的
                        right应该移位到中间位置
                     */
                    right = middle - 1;
                }else {
                    // 条件实际上就是arr[middle]<target
                    /*
                        说明在后半区
                        right是不需要动的
                        left应该向右移位到中间位置
                     */
                    left = middle + 1;
                }
            }
            System.out.println(target + "在目标数组中的下标是：" + res);
        }
    }
}

（2）排序算法

1.冒泡排序
2.快速排序
3.插入排序
4.选择排序
5.希尔排序
6.堆排序
7.归并排序

①冒泡排序

要求：从小到大排序

冒泡排序思路分析：我先拿第一个数和后面的数一一比较大小
冒泡排序需要两层循环嵌套：for

外层for循环控制的是需要各个数之间比较几轮
内层的for循环控制的是每个数的真正的比较

package com.jr.morning;
//排序算法--冒泡排序

public class y3 {
    public static void main(String[] args) {
        int[]arr=new int[]{1,58,46,33,10,5,-8};
       /*要求：从小到大排序
        冒泡排序过程
         1和58 58和46 58和33 58和10 58和5 58和- 8
         1 46 33 10 5 -8 58
         1和46 46和33 46和10 46和5 46和-8
         1 33 10 5 -8 46 58
         1和3333和10 33和5 33和-8
         1 10 5- 8 33 46 58
         1和10 10和5 10和-8
         1 5 -8 10 33 46 58
         1和5 5和-8
         1 -8 5 10 33 46 58
         -8 1 5 10 33 46 58
         */

        for (int i = 0; i < arr.length -1; i++) {
            //已经控制好了比较的次数
            //比较的次数 = 数组的长度 -1
            for (int j = 0; j <arr.length -1 ; j++) {
                if (arr[j]>arr[j+1]){//如果想对数组进行从大到小排序，把>号改成<就可以了
                    //如果前面的后面的大，换位
                    int temp =arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            System.out.print("第"+(i+1)+"轮的比较结果是：");
           for (int i1 : arr){
               System.out.print(i1 +"、");
           }
            System.out.println();
        }



    }
}

冒泡排序的简便操作

package com.jr.morning;
import java.util.Arrays;
public class y4 {
    //冒泡排序的简便操作
    public static void main(String[] args) {
        int [] arr = new int[]{1,58,460,-33,10,5,-8};

        // 从小到大
        Arrays.sort(arr);

        for (int i : arr) {
            System.out.println(i);
        }
    }
}

②选择排序

package com.jr.morning;
//选择排序
public class y5 {
    public static void main(String[] args) {
        /*
            第一轮
                i=0,minIndex=0，里层的for循环int j = 1;j < 7;
                if(arr[0] > arr[1]){}。由于if不满足，则继续下一次的比较。
                j = 2,if(arr[0] > arr[2]){}。由于if不满足，则继续下一次的比较。
                j = 3,if(arr[0] > arr[3]){}。由于if不满足，则继续下一次的比较。
                j = 4,if(arr[0] > arr[4]){}。由于if不满足，则继续下一次的比较。
                j = 5,if(arr[0] > arr[5]){}。由于if满足条件，执行了minIndex = 5.
                j = 6,if(arr[5] > arr[6]){}。由于if不满足，则继续下一次的比较。
                j = 7,if(arr[5] > arr[7]){}。由于if不满足，则继续下一次的比较。
                到此为止，里层的for循环执行完毕。minIndex = 5。执行的
                int temp = arr[5];
                arr[5] = arr[0];
                arr[0] = temp;
                i=0的这次外层循环执行完毕。
                数组变成了-8、25、48、12、10、1、127、56
             第二轮
                i=1,minIndex = 1,
                j = 2,if(arr[1] > arr[2]){}。由于if不满足，则继续下一次的比较。
                j = 3,if(arr[0] > arr[3]){}。由于if满足，minIndex = 3;
                j = 4,if(arr[3] > arr[4]){}。由于if满足，minIndex = 4;
                j = 5,if(arr[4] > arr[5]){}。由于if满足，minIndex = 5;
                j = 6,if(arr[5] > arr[6]){}。由于if不满足，则继续下一次的比较。
                j = 7,if(arr[5] > arr[7]){}。由于if不满足，则继续下一次的比较。
                到此为止，里层的for循环执行完毕。minIndex = 5。执行的
                int temp = arr[5];
                arr[5] = arr[1];
                arr[1] = temp;
                数组变成了-8、1、48、12、10、25、127、56
             第三轮
                i=2;........
         */
        int [] arr = new int[]{1,25,48,12,10,-8,127,56};
        for (int i = 0; i < arr.length; i++) {
            // 假设最小数的下标
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[minIndex]>arr[j]){ // 找到了最小值
                    minIndex = j; //保存最小值的下标
                }
            }
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
            System.out.print("第" + (i+1) + "次比较结果是：");
            for (int i1 : arr) {
                System.out.print(i1 + "、");
            }
            System.out.println();
        }

    }

}

③插入排序

package com.jr.morning;
//插入排序
public class y6 {
    public static void main(String[] args) {
        /*
            第一轮：
                i=0,current=arr[1],int preIndex=0,
                while(0 >= 0 && 25 < arr[0]){}不成立，while循环不启动
                arr[0+1] = arr[0+1]
            第二轮：
                i=1,current=arr[2]=48,int preIndex=1
                while(1 >= 0&&48<25){}不成立，while循环不启动
                arr[1+1] = arr[1+1]
            第三轮：
                i=2,current=arr[3]=12,int preIndex=2
                while(2 >=0 && 12 < 48){
                    arr[3] = arr[2]
                    2--;
                }
                preIndex=1;
                while(1 >=0 && 12 < 25){
                    arr[2] = arr[1];
                    1--;
                }
                preIndex = 0;
                while(0 >=0 && 12 < 1){}不成立，while完事
                arr[1] = 12;
                1,12,25,48,10,-8,127,56
             第四轮：
                i=3,current = arr[4] = 10,int preIndex = 3,
                while(3>=0 && 10 < 48){
                    arr[4] = arr[3];
                    1,12,25,48,48,-8,127,56
                    3--;
                }
                preIndex = 2;
                while(2>=0 && 10 < 25){
                    arr[3] = arr[2];
                    1,12,25,25,48,-8,127,56
                    2--;
                }
                preIndex = 1;
                while(1>=0&& 10 < 12){
                    arr[2] = arr[1];
                    1,12,12,25,48,-8,127,56
                    1--;
                }
                preIndex = 0;
                while(0>=0&&10 < 1){}不成立，while完事
                arr[1] = current = 10;
                1,10,12,25,48,-8,127,56
         */
        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的定义范围：
            /*当上一个数的下标有效不能小于0
             并且还要保证当前的数比他上一个数小，
             这时候，才能让当前数向前移位*/
            while(preIndex >= 0 && current < arr[preIndex]){
                // 移位
                // 前面的数后移一位
                arr[preIndex + 1] = arr[preIndex];
                //
                preIndex--;
            }
            arr[preIndex + 1] = current;
        }
        for (int i : arr) {
            System.out.print(i + "、");
        }
    }
}

三、数组的反转

package com.jsoft.afternoon;

import java.util.Arrays;

/**
 * 数组的反转
 */
public class Ch03 {

    public static void main(String[] args) {
//        int [] arr = new int[]{1,25,48,12,10,-8,127,56};
//        for (int i = arr.length - 1; i >= 0 ; i--) {
//            System.out.println(arr[i]);
//        }
        /*
            思路1：
                创建一个等长的数组
                把当前数组的每一个元素倒着添加到新数组里
                新数组赋值给老数组
                int [] newArr = new int[arr.lenth];
         */
//        int [] newArr = new int[arr.length];
//        for (int i = arr.length - 1; i >= 0 ; i--) {
//            newArr[i] = arr[arr.length - 1 - i];
//        }
        // 新数组赋值给老数组
//        arr = newArr;
//        for (int i : arr) {
//            System.out.println(i);
//        }
        /*
            思路2：
            利用交换的方式
         */
        int [] arr = new int[]{1,25,48,12,10,-8,127,56};
//        for (int i = 0; i < arr.length / 2; i++) {
//            // temp存储的时最后一位
//            int temp = arr[arr.length - 1 - i];
//            arr[arr.length - 1 - i] = arr[i];
//            arr[i] = temp;
//        }
//        for (int i : arr) {
//            System.out.println(i);
//        }
//        Arrays是操作数组的一个工具类
        System.out.println(Arrays.toString(arr));
    }
}

四、数组的扩容

package com.jsoft.afternoon;

import java.util.Arrays;

/**
 * 数组的扩容
 */
public class Ch04 {

    public static void main(String[] args) {
        int [] nums = new int[]{3,4,6};
        // 定义一个新的临时数组
        int [] temp = new int[6];
        for (int i = 0; i < nums.length; i++) {
            temp[i] = nums[i];
        }
        nums = temp;
        System.out.println(Arrays.toString(nums));
    }
}