常见算法（1）

1.基本查找/顺序查找

核心：从0索引之后挨个查找

实现代码：

public class test {
		public static void main(String [] arg) throws ParseException  {
		  int[] arr= {121,85,46,15,55,77,63,49};
		  int number=55;
		  System.out.println(bashi(arr,number));
		}
		public static boolean bashi(int []arr,int number) {
			for(int i=0;i<arr.length;i++) {
				if(number==arr[i]) {
					return true;
				}
			}
			return false;
		}
}

查找某个数据的索引，若考虑数据重复问题，则需要使用集合，将数据索引放入集合中。

public class test {
		public static void main(String [] arg) throws ParseException  {
			//返回数据的索引，需要考虑数据重复问题
		  int[] arr= {121,85,46,15,55,77,63,49,55};
		  int number=55;
		  System.out.println(bashi(arr,number));
		}
		public static ArrayList<Integer> bashi(int []arr, int number) {
			ArrayList<Integer> list=new ArrayList();
			for(int i=0;i<arr.length;i++) {
				if(number==arr[i]) {
					list.add(i);
				}
			}
			return list;
		}
}

2.二分查找

前提条件：数组中的数据必须是有序的

核心：每次排除一半的查找范围

定义min、max、mid

若查找元素在mid左边，min不变，max=mid-1;

若查找元素在mid右边，max不变，min=mid+1;

实现代码：

public class test {
		public static void main(String [] arg) throws ParseException  {
		  int[] arr= {12,35,46,62,88,97,150};
		  int number=88;
		  System.out.println(binary(arr,number));
		}
		public static int binary(int []arr, int number) {
			int min=0;
			int max=arr.length-1;
			while(true) {
				if(min>max) {
					return -1;
				}
				int mid=(min+max)/2;
				if(arr[mid]<number) {
					min=mid+1;
				}else if(arr[mid]>number) {
					max=mid-1;
				}else {
					return mid;
				}
			}
		}
}

3.分块查找

原则：1.前一块中的最大数据，小于后一块中的所有数据；2.块数数量一般等于这个数字的个数开根号。

核心：先确定查找的是那一块，然后在块内挨个查找

分析：

先创建一个Block类，有max（最大值），startindex（起始索引），endindex（结束索引）；

再创建一个block数组，存放创建的对象；

定义方法查找元素下标，还有一个方法查找元素在哪一块：遍历block数组，查找最大值小于元素的块（下标）。得到哪一块，获取起始索引，遍历，在arr中查找元素下标。

public class test {
		public static void main(String [] arg)   {
		  int[] arr= {16,5,9,12,21,18,
				     32,23,37,26,45,34,
				     50,48,61,52,73,66};
		  
		  //分块查找：
		  //建立一个Block类
		  //创建Blockarr数组，存放每个对象的信息
		  //先查找元素是那一层的
		  //再遍历这一层查找元素索引
		  
		  Block b1=new Block(21,0,5); //创建对象
		  Block b2=new Block(45,6,11);
		  Block b3=new Block(66,12,17);
		  //定义一个数组管理三个块
		  Block []block= {b1,b2,b3};
		  System.out.println(find(block,arr,61));
		
		}
		public static int find(Block []block,int[] arr,int number) { 
			int index=ceng(block,number);//查到在哪一层
			if(index==-1) {
				return -1;
			}
			//获取这一层的起始和结束索引
			int startindex=block[index].getStart();
			int endindex=block[index].getEnd();
			//遍历arr
			for(int i=startindex;i<endindex;i++) {
				if(arr[i]==number) {
					return i;
				}
			}
			return -1;
		}
		//查找元素在那一层
		public static int ceng(Block []block,int number) {
			for(int i=0;i<block.length;i++) {
				if(block[i].getMax()>=number) {
					return i;
				}
			}
			return -1;
		}
}
class Block{
	private int max;//每层的最大值
	private int start;//起始索引
	private int end;//结束索引
	public Block() {
		
	}
	public Block(int max,int start,int end) {
		this.setMax(max);
		this.setStart(start);
		this.setEnd(end);
	}
	public int getMax() {
		return max;
	}
	public void setMax(int max) {
		this.max = max;
	}
	public int getStart() {
		return start;
	}
	public void setStart(int start) {
		this.start = start;
	}
	public int getEnd() {
		return end;
	}
	public void setEnd(int end) {
		this.end = end;
	}
	
}