数据结构与算法——数组

线性结构：数组：

对数组的基本操作：

package dataStruct;

public class TestArray {

	public static void main(String[] args) {
		//创建一个数组
		int [] arr1 = new int [3];
		//获取数组的长度
		int length1= arr1.length;
		System.out.println(length1);
		//访问数组中的元素:数组名[下标] 注意:下标从零开始,最大可取到长度—1。
		int element0 = arr1[0];
		System.out.println("element0="+element0);
		//为数组中的元素赋值
		arr1[0]=40;
		System.out.println(arr1[0]);
		arr1[1]=30;
		arr1[2]=70;
		//遍历数组
		for(int i=0;i<arr1.length;i++) {
			System.out.println(arr1[i]);	
		}
		//创建数组的同时为他赋值
		int[] arr2= new int[] {22,56,88,12};
		
		System.out.println("arr2 length:"+arr2.length);

	}

}

将一个数加入的一个数组中:

package dataStruct;

import java.util.Arrays;

public class TestOpArray {

	public static void main(String[] args) {
		//数组的长度不可变
		int[] arr1 =new int[] {9,8,7};
		//Array.toString() 
		//方法将数组直接输出
		System.out.println(Arrays.toString(arr1)); 
		//新数组长度+1
		int[] arr2 =new int[arr1.length+1];
		//遍历数组1将数组1中的数传给数组2
		for(int i=0;i<arr1.length;i++) {
			arr2[i]=arr1[i];
		}
		//设置要添加的数
		int newnumber=6;
		//将新数组的最后一个数值设为要添加的
		arr2[arr2.length-1]=newnumber;
		//改变arr1的指针，使之指向arr2
		arr1=arr2;
		System.out.println(Arrays.toString(arr1));
	}

}

从数组中删除一个元素：

package dataStruct;

import java.util.Arrays;
import java.util.Scanner;


public class TestOpArray2 {

	public static void main(String[] args) {
		int[] arr1=new int[] {6,5,4,3,2};
		System.out.println(Arrays.toString(arr1));
		
        Scanner input =new Scanner(System.in);
        System.out.println("输入想要删除的数的位置");
        int n=input.nextInt();

		int[] arr2=new int[arr1.length-1];
		/*使用一个for
		 * for(int i=0;i<n;i++) { 
		 * 		arr2[i]=arr1[i]; 
		 * } 
		 * for(int j=n+1;j<arr1.length;j++) {
		 * 		arr2[j-1]=arr1[j]; 
		 * }
		 */
		
		//使用两个for循环
		for(int i=0;i<arr1.length;i++) {
			if(i<n) {
				arr2[i]=arr1[i];
			}if(i>n) {
				arr2[i-1]=arr1[i];
			}
		}
		arr1=arr2;
		System.out.println(Arrays.toString(arr1));
	}

}

面向对象的数组：

数组实例:

实例类：

package dataStruct.util;

import java.util.Arrays;

public class MyArray {
	private int[] arr;
	//构造函数
	public  MyArray() {
		 arr=new int[0];	
	}
	//获取数字大小
	public int size() {
		return arr.length;
	}
	//在数组后添加一个元素
	public void add(int newn) {
		int[] arr2=new int[arr.length+1];	
		for(int i=0;i<arr.length;i++) {
			arr2[i]=arr[i];
		}
		arr2[arr2.length-1]=newn;
		arr=arr2;	
	}
	//打印数组
	public void show() {
			System.out.println(Arrays.toString(arr));	
	}
	//删除数组中的元素
	public void delete(int n) {
		if(n<0||n>arr.length-1) {
			throw new RuntimeException("下标越界");
		}
		int[] arr2=new int[arr.length-1];
		for(int i=0;i<arr.length;i++) {
			if(i<n) {
				arr2[i]=arr[i];
			}if(i>n) {
				arr2[i-1]=arr[i];
			}
		}
		arr=arr2;
	}
	//获取数组中的某一个元素
	public int get(int n) {
		return arr[n];	
	}
	//像数组指定位置添加元素
	public void addOne(int n,int a) {
		int [] arr2 =new int[arr.length+1];
		for(int i=0;i<n;i++) {
			arr2[i]=arr[i];
		}
		arr2[n]=a;
		for(int j=n;j<arr.length;j++) {
			arr2[j+1]=arr[j];
		}
		arr=arr2;
	}
	//替换指定位置的元素
	public void set(int index, int element) {
		// 判断下标是否越界
		if (index < 0 || index > arr.length - 1) {
			throw new RuntimeException("下标越界");
		}
		arr[index] = element;
	}
	
	}
}

测试类：

package dataStruct;

import dataStruct.util.MyArray;

public class TestMyArray {

	public static void main(String[] args) {
		MyArray ma=new MyArray();
		ma.show();
		ma.add(5);
		ma.add(7);
		ma.add(6);
		ma.show();
		
		int s=ma.size(); 
		System.out.println(s); 
		
		ma.delete(0); 
		ma.show();
		
		System.out.println(ma.get(1));
		
		ma.addOne(1, 9);
		ma.show();
		
		ma.set(2, 88);
		ma.show();
	}

}

查找算法：

1.先行查找法：

遍历数值挨个找相同

package dataStruct;

public class TestArraySearch {

	public static void main(String[] args) {
	    int[] arr=new int[] {5,6,9,1,3,4,7};
	    //目标元素下标
	    int index=-1;
	    //目标元素值
	    int n=3;
	    for(int i=0;i<arr.length;i++) {
	    	if(arr[i]==n) {
	    		index=i;
	    	}
	    }
	    System.out.println(index);
	}

}

2.二分法查找：

目标数组必须有序

public int binarySearch(int target) {
		//记录开始位置
		int begin = 0;
		//记录结束位置
		int end = elements.length-1;
		//记录中间的位置
		int mid = (begin+end)/2;
		//循环查找
		while(true) {
			//什么情况下没有这个元素？
			//开始在结束位置之后或重合,没有这个元素
			if(begin>=end) {
				return -1;
			}
			//判断中间的这个元素是不是要查找的元素
			if(elements[mid]==target) {
				return mid;
				//中间这个元素不是要查的元素
			}else{
				//判断中间这个元素是不是比目标元素大
				if(elements[mid]>target) {
					//把结束位置调整到中间位置前一个位置
					end=mid-1;
				//中间这个元素比目标元素小
				}else {
					//把开始位置调整到中间位置的后一个位置
					begin = mid+1;
				}
				//取出新的中间位置
				mid=(begin+end)/2;
			}
		}
	}