Java_数组，排序，查询学习

1.数组可以存放多个同一类型数据。

2.对象数组以及赋值，创建一个对象数组，初始化赋值的时候要引用一下对象

3.简单数据类型(int,float)数组，可直接赋值

4.对象数组在定义之后，赋值时需要再次为每个对象分配空间【即:new 对象】

5.数组大小必须事先指定

6.数组名可以理解为执向数组首地址的引用

7.数组的下标是从0开始编号的

8.排序的分类

1. 内部排序：指将需要处理的所有数据加载到内部存储器中进行排序（交换式排序法、选择式排序法、插入式排序法）

    （1） 交换式排序：运用数据值比较后，依判断规则对数据位置进行交换（ 冒泡排序、快速排序）    

• 冒泡排序：逐一比较，如果前一个数比后一个数大，交换位置

class Bubble{
    //排序方法
    public void sort(int arr[]){
        int temp=0;

        //排序开始
        //外层循环，决定一共走几趟
        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]){
                    //换位
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
}

• 快速排序(占用内存大，速度最快)

  class QuickSort{
      public void sort(int left,int right,int arr[]){
          int l=left;
          int r=right;
          int pivot=arr[(left+right)/2];
          int temp=0;
          while (l<r){
              while(arr[l]<pivot)
                  l++;
              while (arr[r]>pivot)
                  r--;
              if(l>=r)
                  break;
              temp=arr[l];
              arr[l]=arr[r];
              arr[r]=temp;
  
              if(arr[l]==pivot)
                  --r;
              if(arr[r]==pivot)
                  ++l;
          }
  
          if(l==r){
              l++;
              r--;
          }
          if(left<r)
              sort(left,r,arr);
          if(right>l)
              sort(l,right,arr);
      }
  }

  
  

（2）简单选择排序：

class Select{
    //选择排序
    // 我认为第一个数就是最小的额
    int temp=0;
    public void sort(int arr[]){
        for(int j=0;j<arr.length-1;j++){
            int min=arr[j];
            //记录最小数的下标
            int minIndex=j;

            for(int k=j+1;k<arr.length-1;k++){
                if(min>arr[k]){
                    //修改最小
                    min=arr[k];
                    minIndex=k;
                }
            }
            //当退出for就找到这次的最小值
            temp=arr[j];
            arr[j]=arr[minIndex];
            arr[minIndex]=temp;
        }
    }
}

     （3） 插入排序法

class InsertSort{
    public void sort(int arr[]){
        for(int i=1;i<arr.length;i++){
            int insertVal=arr[i];
            //insertVal准备和前一个数比较
            int index=i-1;
            while(index>=0&&insertVal<arr[index]){
                //把arr[index]向后移动
                arr[index+1]=arr[index];
                //让index向前移动
                index--;
            }
            //将insertVal插入到适当的位置
            arr[index+1]=insertVal;
        }
    }
}              

（2）外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。（合并排序、直接合并排序）

9.查找：顺序查找，二分查找(数列是有序的)

（1）二分查找

class BinaryFind{
    public void find(int leftIndex,int rightIndex,int val,int arr[]) {
        //首先找到中间的数
        int midIndex = (rightIndex + leftIndex) / 2;
        int midVal = arr[midIndex];

        if (rightIndex >= leftIndex) {
            //开始查找
            if (midVal > val) {//要找的数比midVal小
                //在arr左边数中找
                find(leftIndex, midIndex-1, val, arr);
            } else if (midVal < val) {//要找的数比midVal大
                //在arr的右边的数查找
                find(midIndex+1, rightIndex, val, arr);
            } else if (midVal == val) {
                System.out.println("找到下标" + midIndex);
            }
        }
    }
}

10.二维数组：类型  数组名[] []=new 类型 [大小] [大小]

                      类型  [] [] 数组名=new 类型 [大小] [大小]

                      类型  []  数组名 [] =new 类型 [大小] [大小]

11.二维数组动态赋值(可以理解为一位数组的数组，例如a[m][n],将a[m]看成一个整体代换成s就是s[n],一个一维数组)

思路：先定义一个二维数组，给二维数组先指定一维的长度,然后将这个看成是一个整体再去定义二维的长度.

String s[][];//String [][]s   String []s[]
        s=new String[4][];
        for(int i=0;i<s.length;i++){
            s[i]=new String[i+1];//动态的给第一维度对应的第二维度定义大小
            //System.out.println(i+" "+s[i].length);
                for(int j=0;j<s[i].length;j++){
                    s[i][j]=new String("我是第"+i+"行,我的兄弟有"+i+"个，我在第"+j+"列,即"+"s["+i+"]"+"["+j+"]");//new String("我是第"+i+"行,我的兄弟有"+i+"个，我在第"+j+"列")
                }
        }
        for(int i=0;i<s.length;i++){
            for(int j=0;j<s[i].length;j++){
                System.out.println(s[i][j]);
            }
        }