1.数组概念

1.1数组用一个标识符和下标来表示，下标可以区分数组中不同的元素。如果一个数组只有一个下标，则称为一维数组。有两个下标，则为二维数组。一般只用到三维数组，而一维和二维数组较常用。

数组是一种引用类型，在内存中数组元素和数组变量是分开存放的，其中引用变量存储在栈内存中（stack），数组元素则是在堆内存（heap）中。

数组是一种基本数据结构，用来顺序存储同一类型值的集合。

1.2创建并初始化数组

声明数组的名字和类型、创建数组、初始化数组元素。完整写法略。

简化写法：

1 int a[]=new int [100];

 

1.3数组别名

数组名表示整个数组，如果将一个数组的变量赋予另一个变量，那么两个变量将会指向同一个数组。

1 int a[]=new int[100];
2 a[1]=102;
3 int b[]=a;
4 b[1]=2;

 

此时a[1]的值也变为2。

2.数组的排序

2.1冒泡排序：对于一组包含n个数据的一组记录，最坏的情况要进行n-1个排序。

 每次排序都会把最大的数固定出来放在最后，固定后的数就不再参与下一次排序了。

1 import java.util.Scanner;
 2 public class 冒泡排序 {
 3     public static void bubbleSort(int []data,int len)
 4     {
 5         for(int i=0;i<len-1;i++)
 6         {
 7             boolean flag=false;
 8             for(int j=0;j<len-1-i;j++)
 9             {
10                 if(data[j]>data[j+1])
11                 {
12                     int temp=data[j];
13                     data[j]=data[j+1];
14                     data[j+1]=temp;
15                     flag=true;
16                 }
17             }
18             if(!flag)//未发生交换，已经有序
19                 break;
20         }
21     }
22     public static void main(String[] args) {
23         Scanner cin=new Scanner(System.in);
24         while (cin.hasNext()) {
25             int n = cin.nextInt();
26             int a[] = new int[n];
27             for (int i = 0; i < n; i++) {
28                 a[i] = cin.nextInt();
29             }
30             bubbleSort(a,n);
31             for(int i:a){ //for-each循环
32                 System.out.println(i);
33             }
34         }
35     }
36 }

 

 

快速排序（重要！）：二分思想，在一组数据中取一个数据（如第一个）作为分界值，所有比分界值小的数放到左边，比分界值大的放在右边，得到两个子序列，两个子序列分别再进行排序，直到左右只剩一个数为止。

完整代码：

import java.util.Scanner;
public class 快速排序 {
    public static void quickSort(int[] data,int start,int end)
    {
        int i=start;int j=end;
        if(i>=j)//退出条件
            return;
        boolean flag=true;//true表示从右至左搜索，false表示从左至右搜索
        while (i!=j)//直到相遇停止，意味这一轮交换完成
        {
            if(data[i]>data[j])
            {
                int temp=data[i];
                data[i]=data[j];
                data[j]=temp;
                flag=!flag;//有交换则改变flag，这决定下一次ij改改变谁（搜索往哪个方向走）
            }
            if(flag)
                j--;
            else
                i++;
        }
        i--;j++;//递归，二分思想，分别对ij左右两侧再次重复
        quickSort(data,start,i);
        quickSort(data,j,end);
    }
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        while (cin.hasNext()) {
            int n = cin.nextInt();
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = cin.nextInt();
            }
            quickSort(a,0,n-1);
            for(int i:a){ //for-each循环
                System.out.println(i);
            }
        }
    }
}

 2.3二分查找 

优点：折半法查找，比较次数少，速度快；缺点：必须保证有序，难以插入删除。

适用于不经常变动并且查找频繁的有序列表。

import java.util.Arrays;
import java.util.Scanner;
public class Array {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[] a=new int[n];
        for(int i=0;i<a.length;i++){
            a[i]=in.nextInt();
        }
        for(int i:a){
            System.out.print(i+" ");
        }
        System.out.println(binarySearch(10,a));//自己写方法
        System.out.println(Arrays.binarySearch(a,10));//jdk方法
    }
//二分查找
    public static int binarySearch(int key,int[] a){
        Arrays.sort(a);
        int lo=0,hi=a.length;
        while(lo<=hi){
            int mid=(lo+hi)>>1;
            if(a[mid]>key){
                hi=mid-1;
            }
            if(a[mid]<key){
                lo=mid+1;
            }
            if(a[mid]==key){
                return mid;
            }
        }
        return -1;
    }
}