Java笔记(八)……数组

数组的概念

同一种类型数据的集合。其实数组就是一个容器。

数组的好处

可以自动给数组中的元素从0开始编号，方便操作这些元素。

数组的格式

元素类型[] 数组名 = new 元素类型[个数];

int[] arr = new int[5];

元素类型[] 数组名 = new 元素类型[]{元素1,元素2,……};

int[] arr = new int[]{1,3,5,7};

元素类型[] 数组名 = {元素1,元素2,……};

int[] arr = {1,3,5,7};

内存结构

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：

用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：

数组和对象，通过new建立的实例都存放在堆内存中。

每一个实体都有内存地址值

实体中的变量都有默认初始化值

实体不再被使用，会在不确定的时间内被垃圾回收器回收

数组的内存结构

二维数组

格式

格式一：int[][] arr = new int[2][3];

格式二：int[][] arr = new int[2][];

格式三：int[][] arr = {{2,3,4}{5,6,7}};

特殊格式：int[] x,y[];:此处，x为一维数组，y为二维数组

数组的常见操作

冒泡排序

class Sort
{
    private Sort(){}

    //exchange
    private static void exchange(int[] arr,int x,int y)
    {
        arr[x] = arr[x]^arr[y];
        arr[y] = arr[x]^arr[y];
        arr[x] = arr[x]^arr[y];
    }

    //bubble sort
    public static void bubbleSort(int[] arr)
    {
        for(int x = 0 ; x < arr.length-1 ; x ++)
        {
            for(int y = 0 ; y < arr.length-x-1 ; y ++)
            {
                if(arr[y] > arr[y+1])
                {
                    exchange(arr,y,y+1);
                }
            }
        }
    }

    //print arr
    public static void printArr(int[] arr)
    {
        for(int x = 0 ; x < arr.length ; x ++)
        {
            if(x != arr.length-1)
                System.out.print(arr[x]+",");
            else
                System.out.println(arr[x]);
        }
    }
}
class SortDemo
{
    public static void main(String[] args)
    {
        int[] arr = {8,7,6,5,4,3,1,2};

        Sort.printArr(arr);

        Sort.bubbleSort(arr);

        Sort.printArr(arr);
    }
}

折半查找

class Search
{
    private Search(){};

    //half search
    public static int halfSearch(int[] arr,int key)
    {
        int min,mid,max;

        min = 0;
        max = arr.length-1;


        while(max >= min)
        {
            mid = (min+max)/2;

            if(key < arr[mid])
                max = mid - 1;
            if(key > arr[mid])
                min = mid + 1;
            if(key == arr[mid])
                return mid;
        }
        return -1;
    }

}
class SearchDemo
{
    public static void main(String[] args)
    {
        int[] arr = {1,2,3,4,5,6,7,8,9};

        int index = Search.halfSearch(arr,10);

        if(index == -1)
            System.out.println("No key in this arr!");
        else
            System.out.println("index = "+index);
    }
}

幸运儿问题

/*
10个小孩围成一圈，从第一个小孩算起，数到3，
则第三个小孩出列，接着向下数，数到3，
则该小孩出列，求最后留下的小孩是哪个
*/

class LuckyNumber
{
    public static void main(String[] args)
    {
        findLuck(10);
    }

    public static void findLuck(int num)
    {
        int[] arr = new int[num];

        for(int i = 0 ; i < arr.length ; i ++)
        {
            arr[i] = 1;
        }
        //用于实际计数
        int pos = 0;
        //最终需要出圈的人数
        int size = num;

        while(true)
        {
            for(int i = 0 ; i < arr.length ; i ++)
            {
                pos++;
                if(arr[i] == 0)
                    pos--;
                else if(pos%3 == 0)
                {
                    arr[i] = 0;
                    size--;
                    //当所有人都出去之时，最后一个即为结果
                    if(size == 0)
                    {
                        System.out.println("index = "+i);
                        return;
                    }
                }
            }
        }
    }
}