01_数组是如何实现的？

数组在计算机中是一个连续的内存空间

我们可以通过随机访问的方式来访问他的元素

特性：内存地址是按顺序分配的

数组的结构

数组在内存中的结构

一维数组的代码实现

Java版：

 		Long[] arr = new Long[10]; //声明大小
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (long) i; //初始化
        }

二维数组的代码实现

Java版：

 // 二维数组
        Long[][] multiArr = new Long[10][10];
        // multiArr.length取的是行的长度 multiArr[i].length取的是列的元素
        for (int i = 0; i < multiArr.length; i++) {
            for (int j = 0; j < multiArr[i].length; j++) {
                multiArr[i][j] = (long)i * j;
            }
        }

其实不难发现二维数组是一种抽象出来的结构，分配空间就是行数的列长度的有序一段内存。

有序数组

例如: 1,2,3,4,5,7,8 这样的一个数组就是有序数组

但是通常我们数组都是无序的例如: 3,2,1,4,6,7,5,2....，所以我们需要将数组进行排序操作Sort

这里介绍几个简单排序方式吧，等后面认识其他数据结构来讲解高级排序

• 冒泡排序

  // BubbleSort代码实现
  public class BubbleSort implements SortAble<Integer> {
      @Override
      public Integer[] sort(Integer[] arr) {
          int len = arr.length;
          for (int i = 0; i < len; i++) {
              for (int j = i + 1; j < len; j++) {
                  if (arr[i] > arr[j]) {
                      swap(arr, i, j);
                  }
              }
          }
          return arr;
  }
  

  // swap代码
  default T[] swap(T[] arr, int i, int j) {
          // count.SWAP_NUM++; // 用来计算交换次数的，可以注释掉
          T temp = arr[i];
          arr[i] = arr[j];
          arr[j] = temp;
          return arr;
  }
  

• 选择排序

  public class SelectSort implements SortAble<Integer> {
      @Override
      public Integer[] sort(Integer[] arr) {
          int min;
          for (int i = 0; i < arr.length; i++) {
              min = i;
              for (int j = i; j < arr.length; j++) {
                  if (arr[min] > arr[j]) {
                      min = j;
                  }
              }
              swap(arr, min, i);
          }
          return arr;
      }
  

• 插入排序

  public class InsertSort implements SortAble<Integer> {
      @Override
      public Integer[] sort(Integer[] arr) {
          int in, out;
          for (out = 1; out < arr.length; out++) {
              int temp = arr[out];
              in = out;
              while (in > 0 && arr[in - 1] >= temp) {
                  arr[in] = arr[in - 1];
                  --in;
              }
              arr[in] = temp;
          }
          return arr;
      }
  

有序数组的查找

如何快速的查找到数组中某个元素呢，我们会有个二分查找的算法

// 二分查找
    public int binaryFind(int[] arr,int ele){
        int min = 0;
        int max = arr.length - 1;
        int middle = (min + max) / 2;

        while (min < max){
            if (ele < arr[min]){
                return -1;
            }else if (ele > arr[max]){
                return -1;
            }else if (ele < arr[middle]){

                middle = (min + middle)/2 + 1;
            }else if (ele > arr[middle]){
                middle = (middle +  max)/2 + 1;
            }else if (ele == arr[middle]){
                return  middle;
            }
        }

        return  -1;

    }