数值与常见排序

数组

概念

存储一组相同数据类型的集合

四要素

数据类型 标识符 长度 下标

特点

• 数组是用来存储一组相同数据类型的数据结构。
• 数组中的元素可以是任何数据类型(基本类型和引用类型)。
• 数组有一个对应的索引，可以通过索引访问数组中的每个元素。
• 数组被创建好之后，它的大小（数组长度）是不能改变的，但是数组中的各个元素是可以被改变的。
• 数组变量属于引用数据类型。

声明与赋值

先声明再分配空间

语法

int[] array; //数据类型[] 数组名
array = new int[5]; //数组名 = new 数据类型[长度]

声明并分配空间

语法

int[] array = new int[5]; //数据类型[] 数组名 = new 数据类型[长度]

声明并赋值(繁)

语法

int[] array = new int[]{value1,value2,....,value3};

注意

• 赋值的大括号后面有分号
• 长度由value的数量决定 而不是逗号的数量

声明并赋值(简)

语法

int[] array = {value1,value2,....,value3};

注意

• 赋值的大括号后面有分号
• 声明部分不能换行，赋值部分可换行

初始化

动态初始化

数组的创建和数组的初始化分开完成，先创建空间后赋值

int[] array = new int[3];
a[0] = 1;
a[1] = 2;  //通过元素索引(下标)来给数组元素赋值
a[2] = 3;

静态初始化

数组的创建同时对数组进行初始化

int[] array = new int[]{1,2,3};  //定义并创建数组 并初始化数组的元素为1、2、3 同时也将数组的长度限定为3

遍历

从头至尾，逐一对数组的每个元素进行访问

数组名.length可动态获取数组长度

public class TestArray{
    public static void main(String[] args){
        int array[] = {1,2,3,4,5};
        for(int i =0;i<array.length;i++){
            System.out.print(array[i]+"\t");
        }
    }
}

默认值

在访问没有进行赋值的数组元素时，系统会输出默认值

• 整数：0
• 小数：0.0
• 字符：空格
• 布尔：false
• 其他：null

数组扩容

数组创建后长度不可变，扩容方式有一些三种

1. 先创建一个长度大于原数组的新数组，在将老数组的元素依次复制到新数组

   		int old[] = new int[] {12,3,1,31,3};
   		int newArray[] = new int[old.length*2];
   		for(int i=0;i<old.length;i++) {
   			newArray[i] = old [i];
   		}
   		for(int i=0;i<newArray.length;i++) {
   			System.out.print(newArray[i]);
   		}
   

2. System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);

   		int old[] = new int[] {12,3,1,31,3};		
   		int newArray2[] = new int[old.length*2];
   		System.arraycopy(old, 0, newArray2, 0,old.length);
   		for(int i=0;i<newArray2.length;i++) {
   			System.out.print(newArray2[i]);
   		}
   

3. java.util.Arrays.copyOf(原数组,新长度);//返回带有原值的新数组

   		int old[] = new int[] {12,3,1,31,3};
   		int newArray3[] = Arrays.copyOf(old, old.length*2);
   		for(int i=0;i<newArray3.length;i++) {
   			System.out.print(newArray3[i]);
   		}
   

地址的替换

内层堆栈图

数组作为引用数据类型，其变量存储的时数组的地址 完成元素赋值后 需要将新数组地址赋给原变量进行替换

数组的传参

public class Test{
    public static void main(String[] args){
        int nums[] = {1,2,3,4,5};
        printArray(nums);
    }
    public static void printArray(int[] array){
        for(int i =0;i<array.length;i++){
            System.out.print(array[i]+"\t")
        }
    }
}

如上图代码

• 在方法调用时 将nums中的地址赋给array，让二者指向同一数组
• 传递参数时 基本数据类型传的是变量中的值，引用类型传递的是变量中的地址

图解

数组的返回值

在调用数组类型的返回值方法时，方法执行后，返回的是数组的地址。

可变长参数

概念

可接受多个同类型的实参 个数不限 使用方式与数组相同

语法

public class TestArray3 {

	public static void main(String[] args) {
		test("第",1,2,3,4); //可为可变长参数赋0-n个值
	}
	public static void test(String name,int...nums) { //定义了一个int类型的可变长参数
		for (int i = 0; i < nums.length; i++) {
			System.out.println(name+nums[i]);
		}
	}
	
}

注意事项

• 有可变长参数作为形参时，可变长参数要放在最后
• 一次只能有一个可变长参数
• 不能和int一起用(无法分辨是int的值还是int…的值)

数组排序

冒泡排序

相邻两个数比较大小 互换位置

public static void sort(int[] a) {
		for(int i=0;i<a.length-1;i++) {
			for(int j = 0;j<a.length-1-i;j++) {
				if(a[j]>a[j+1]) {
					int temp =0;
					temp=a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
		}
	}

选择排序

固定值与其他值比大小 互换位置

public static void selectSort(int[] a) {
		for(int i=0;i<a.length-1;i++) 
		{
			int index = i;
			for(int j=i+1;j<a.length;j++) 
			{
				if(a[j]<a[index]) 
				{
					int temp = a[index];
					a[index] = a[j];
					a[j] = a[index];
					
				}
			}
			
		}
	}

JDK排序

java.util.Arrays.sort(数组名); //jdk提供，默认升序

import java.util.Arrays;
Arrays.sort(array);

数组倒序

元素值顺序不变

将数组从最后一位开始循环向前输出 (视觉效果，数组中值顺序不变)

for(int i = array.length-1;i>=0;i--){
    System.out.print(array[i]+"\t")
}

元素值顺序改变

折半法将数组元素对半交换位置(第一位与最后一位交换)，数组中值顺序改变

for(int i =0 ;i<array.length/2;i++){
	int temp = array[array.length-1-i];
	 array[array.length-1-i] = array[i];
	 array[i] =  array[array.length-1-i];
}

数组插入

后置位插入

将数组插入最后一位，并通过移位保持数组升序

int nums[] = {5,18,26,33,40,0};

		int num=28;
		int index = nums.length-1;
		
		for (int i = 0; i < nums.length; i++) {
			if(nums[i] > num) {
				index = i;
				break;
			}
		}
		
		for (int i = nums.length-1; i >index ; i--) {
			nums[i] = nums[i-1];
		}
		nums[index] = num;
		
		for (int i = 0; i < nums.length; i++) {
			System.out.print(nums[i]+"  ");
		}

首位插入

将数组插入第一位，并通过移位保持数组升序

		int nums[] = {0,5,18,26,33,40};
		int index = 0;
		int num = 28;
		for (int i = 0; i < nums.length; i++) {
			if(nums[i]>num) {
				index = i-1;
				break;
			}
		}
		for (int i = 0; i < index; i++) {
			nums[i] = nums[i+1];
		}
		nums[index] = num;
		
		for (int i = 0; i < nums.length; i++) {
			System.out.print(nums[i]+"  ");
		}

指定位置插入

将数组指定位置插入，并通过移位保持数组升序

public static int[] into(Scanner input,int[] array) {
		System.out.println("请输入你要插入的位置");
		int position = input.nextInt();
		System.out.println("请输入你要插入的值");
		int num = input.nextInt();
		int newArray[] = new int[array.length*2];
		for (int i = 0; i < array.length; i++) {
			newArray[i] = array[i];
		}
		for (int i = newArray.length-1; i > position; i--) {
			newArray[i] = newArray[i-1];
		}
		newArray[position] = num;
		return newArray;
	}

二维数组

概念：一维数组中的一维数组

创建语法

• 先声明在分配空间

  数据类型[][] 数组名;
  数组名 = new 数据类型[高维长度][低维长度];
  

• 声明并分配空间

  数据类型[][] 数组名= new 数据类型[高维长度][低维长度];
  

• 声明并赋值(繁)

  数据类型[][] 数组名= new 数据类型[高维长度][]; //不规则数组，自行new低维长
  

• 声明并赋值(简)

  数据类型[][] 数组名 = {{1,2,3},{4,5},{6,7}}; //显式初始化
  

  遍历

  使用双下标访问元素第一个下标代表：行号(高维下标)，第一个下标代表：列号(低维下标)

  for(int i = 0;i<array.length;i++){
      for(int j = 0;j<array[i].length;j++){
          System.out.print(array[i][j]+"\t");
      }
  }
  

  内存分配

  高维数组中的每一个元素，保存了低维数组的地址。