2022-07-15第二组 曹雨Java03 初学算法 数组的操作

算法：

数据结构：

1.数组是最基本的数据结构，是一张表，一张线性表（数据元素之间是一对一的关系，除了第一个和最后一个，其余都是收尾连接）
2.链表单向链表，双向链表
3.树
4.图深度优先，广度优先

数组一些思想：

二分发：

public class CH02 {
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[0] || target > arr.length-1){
        System.out.println(target+"在目标数组中不存在");
    }   else {
        //用来保存找到的下标的值
        int res = -1;
        while (left <= right){
           int middle = (left + right)/2;
            if(arr[middle] == target){
                //找到了，中间的数恰巧就是我们需要找的shu
                 res = middle;
                 break;
            }else if(left < middle){
                //要找的数在前搬去
  //                   维护left和right
                //right需要 移位到中间//
                right = middle -1;
            }else {
                //条件实际上是[middle<target]
                /*
                说明在后半区

                 */
                left = middle +1;
            }
        }
        System.out.println();
    }
  }
}

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

排序换位时，一定要借助一个第三方。

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

线性排序：

  int [] arr = new int[]{1,58,46,33,10,5,-8};
    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) {
            System.out.println("你要找的数是：" + num + "，在目标数组中的下标是：" + i);
            flag = true;
            index = i;
            break;
        }
    }
      if(index != -1) {
          System.out.println("你要找的数是：" + num + "，在目标数组中的下标是：" + index);
        }else {
          System.out.println("你要找的数是：" + num + "，在目标数组中不存在");
      }
  }
}

冒泡排序：

public class Ch03 {

public static void main(String[] args) {
    int [] arr = new int[]{1,58,460,-33,10,5,-8};
                    for (int i = 0; i < arr.length - 1; i++) {
        //已经控制好了比较的次数
        // 比较的次数 = 数组的长度 - 1
        for (int j = 0; j < arr.length - 1 - i; 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();
      }

    }
}

选择排序：

public static void main(String[] args) {
    //选择排序
         int [] arr = new int[]{12,34,56,123,81,489,3};


         //外层for循环
         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[i];
             arr[i] = arr[minIndex];
             arr[minIndex] = temp;
             System.out.println("第"+(i+1)+"次比较结果是：");
             for (int i1 : arr) {
                 System.out.print(i1+"、");
             }
         }
    System.out.println();

}

插入排序：

小的数往前插

     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;
        // 当上一个数的下标有效不能小于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 + "、");
    }
}

数组的反转

思路1：

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：

       /*
          思路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));
  }
}

数组的扩容
（可以理解为一个固定的组合）

         public class Ch04 {

public static void main(String[] args) {
    Scanner sc =new Scanner(System.in);
    int a = sc.nextInt();
    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));
  }
}

总结：

今天浅浅学习了一些算法的知识，主要是针对数组。我们学习了一些有关数组的操作。在其中设计到了算法的思想。在学校时，我们在数据结构课上几乎都学过，但是没有涉及到具体的代码实现，今天使用Java语言进行具体编写后。感觉程序真的是特别灵活，创造性特别强的一个东西。使用不同的算法实现同样的功能，使用不同的思想去思考具体的问题。各种不同的基本语法相互配合，嵌套。感觉真的很神奇。虽然我的“插入排序”并没有搞懂。但是对编程的兴趣有所提升，以后继续努力，提升自己的编程思想。