package com.xun.test;
import java.util.Random;
public class Test {
/**
* 随机数生成器
*
* @param scope
* 数值的大小范围
* @param amount
* 数据个数
* @return 返回一个指定数值范围的数字个数数组
*/
public static int[] generator(int scope, int amount) {
int[] datas = new int[amount];
Random random = new Random();
for (int i = 0; i < amount; i++) {
datas[i] = random.nextInt(scope);
}
return datas;
}
/**
* 展示数组里面的单个信息
*
* @param datas
*/
public static void showInfo(int[] datas) {
for (int d : datas) {
System.out.print(d + "\t");
}
System.out.println();
}
/**
* 冒泡
*
* @param datas
* 需要排序的INT类型数组
* @return 返回一个有序的IN类型的数组
*/
public static int[] bubble(int[] datas) {
for (int i = 0; i < datas.length; i++) { // 以第I个索引的数值作为基点
for (int j = (i + 1); j < datas.length; j++) { // 把这个基点和这个基点位置以后的数值进行比较,并进行大小替换,达到当前基点的位置的数值是最小数值
int tempData = datas[i];
if (datas[i] > datas[j]) {
datas[i] = datas[j];
datas[j] = tempData;
}
}
}
return datas;
}
/**
* 选择排序:改进了冒泡排序,降低类交换的次数。通过记录交换的索引位置,在进行一次以某数值为基点的比较结束后,通过最终的索引来进行交换
*
* @param args
*/
public static int[] SelectionSort(int[] datas) {
for (int i = 0; i < datas.length; i++) { // 以第I个索引的数值作为基点
int tempIndex = i; // 需要替换的索引
int referenceValue = datas[i];
for (int j = (i + 1); j < datas.length; j++) { // 把这个基点和这个基点位置以后的数值进行比较,并进行大小替换,达到当前基点的位置的数值是最小数值
if (referenceValue > datas[j]) {
referenceValue = datas[j];
tempIndex = j;
}
}
int tempValue = datas[i];
datas[i] = datas[tempIndex];
datas[tempIndex] = tempValue;
}
return datas;
}
/**
* 二分查找:前提是需要一个有序的数组,在数组中通过比较进行对折的缩小范围来查找目标数据,基本的思路就是首先取平均值,通过和平均值的比较,
* 来确定数值的范围是在左边还是右边,依次循环来减少查找的范围
*
* @param datas
* 查询的数组
* @param findData
* 需要查询的数据
* @return true 查询成功 false 查询失败
*/
public static boolean binarySearch(int[] datas, int findData) {
int startPositon = 0;
int endPositon = datas.length;
int pointerIndex = 0;
boolean response = false;
while (startPositon <= endPositon) {
pointerIndex = (startPositon + endPositon) / 2;
if (findData > datas[pointerIndex]) {
startPositon = pointerIndex;
} else if (findData < datas[pointerIndex]) {
endPositon = pointerIndex;
} else {
response = true;
break;
}
}
return response;
}
/**
* 递归实现二分法查找
* @param data 查找的数组
* @param startPosion 数组查找的开始范围
* @param endPosition 数组查找的结束范围
* @param targetValue 需要查找的数值
* @return
*/
public static boolean binarySearchRecursion(int[] datas, int startPostion, int endPosition, int targetValue) {
if(startPostion <= endPosition) {
int pointerIndex = (startPostion + endPosition) / 2;
if (targetValue > datas[pointerIndex]) {
startPostion = pointerIndex + 1; //当前索引值pointerIndex已经比较了,对于程序优化,直接从下一个索引开始
return binarySearchRecursion(datas,startPostion,endPosition,targetValue);
} else if (targetValue < datas[pointerIndex]) {
endPosition = pointerIndex - 1;
return binarySearchRecursion(datas,startPostion,endPosition,targetValue);
} else {
return true;
}
}else {
return false;
}
}
/**
* 插入排序:通过标记基点,与左边的元素挨个进行比较,如果左边的数据比右边的大,则移动到右边,依次比较,知道左边的数据比右边的数据小,那么插入当前基点到当前位置
* 主要就是给基点在左边跟它找到适合的位置
* @param datas
* @return
*/
public static int[] insertionSort(int[] datas) {
int leftIndex;
int rightIndex;
for(rightIndex = 1; rightIndex < datas.length; rightIndex++) { //设置比较的基点数据
int tempValue = datas[rightIndex];
leftIndex = rightIndex;
while(leftIndex > 0 && datas[leftIndex-1] >= tempValue) {
datas[leftIndex] = datas[leftIndex-1];
--leftIndex;
}
datas[leftIndex] = tempValue;
}
return datas;
}
public static void main(String[] args) {
int[] datas = Test.generator(50, 10);
Test.showInfo(datas); // 原始数据
// Test.showInfo(Test.bubble(datas)); //冒泡算法排序
// Test.showInfo(Test.SelectionSort(datas));
//int[] datas = { 0, 6, 10, 12, 16, 21, 25, 26, 42, 48, 62 };
//普通的二分查找
/*if (Test.binarySearch(datas, 62)) {
System.out.println("数据存在");
} else {
System.out.println("数据不存在");
}*/
//用递归进行查找
/*if (Test.binarySearchRecursion(datas, 0, datas.length-1, 22)) {
System.out.println("数据存在");
} else {
System.out.println("数据不存在");
}*/
//插入排序
Test.showInfo(Test.insertionSort(datas));
}
}