JAVA常用基本算法

基本步骤： a、初始化：设定有序区为第一个元素，设定无序区为后面所有元素 b、依次取无序区的每个元素 c、通过二分法查找有序区，返回比这个数小的最大数 d、保留此位置数据 e、从此位置的元素到有序区的最后一个元素，依次后移 f、用保留的数据填充此位置 代码实现： public class Test {
return binarySearch(arr, num, iMid + 1, iMax); } }
4.3 排序
4.3.1 排序之插入排序
4.3.1.1 插入排序之直接插入排序
算法思路：直接插入排序(straight insertion sort)是一种最简单的排序方法。它的基本操
作是将一个记录插入到一个长度为 m (假设)的有序表中，使之仍保持有序，从而得到一个新
Baidu Nhomakorabea
for (int j = i; j > m; j--)
a[j] = a[j-1]; //整体向后移动一个位置
a[m] = iTmp;
//m 是 a[i]应该呆的位置
}
}
public static int findPosition(int a[], int num, int iMin, int iMax) {
的长度为 m + 1 的有序表。设有一组关键字｛ K1 ， K2 ，…， Kn｝；排序开始就认为 K1
是一个有序序列；让 K2 插入上述表长为 1 的有序序列，使之成为一个表长为 2 的有序
序列；然后让 K3 插入上述表长为 2 的有序序列，使之成为一个表长为 3 的有序序列；
依次类推，最后让 Kn 插入上述表长为 n-1 的有序序列，得一个表长为 n 的有序序列。
public static void main(String args[]) {
System.out.println(System.currentTimeMillis()); fun(); System.out.println(System.currentTimeMillis()); } public static void fun() { double a = 0; for(int i = 0; i < 10000; i++)
public static void main(String args[]) {
int iArr[] = {32, 9, 78, 44, 29, 18, 97, 49, 56, 61}; System.out.println("数组的所有元素为："); for(int i : iArr)
System.out.print(i + " "); System.out.println();
4.2 查找
4.2.1 查找之线性查找（直接查找）
算法思路：从数组的第一个元素开始查找，并将其与查找值比较，如果相等则停止，否 则继续下一个元素查找，直到找到匹配值。
注意：被查找的数组中的元素可以是无序的、随机的。 实例： import java.util.*; public class Demo1 {
System.out.print(i + " "); System.out.println();
System.out.print("请输入你要查找的元素："); Scanner scan = new Scanner(System.in); int iNum = scan.nextInt();
int index = binarySearch(iArr, iNum, 0, iArr.length-1); if(index == -1)
int i = 0; for(; i < arr.length; i++) {
if(arr[i] == num) return i;
} return -1; } }
4.2.2 查找之折半查找（二分查找）
算法思路：假设被查找数组中的元素是升序排列的，那我们查找值时，首先会直接到数 组的中间位置(数组长度/2)，并将中间值和查找值比较，如果相等则返回，否则，如果当前 元素值小于查找值，则继续在数组的后面一半查找(重复上面过程)；如果当前元素值大于查 找值，则继续在数组的前面一半查找，直到找到目标值或者无法再二分数组时停止。
实例：
//49, 38, 65, 97, 76, 13, 27
初始情况
//[49], 38, 65, 97, 76, 13, 27 //[38, 49], 65, 97, 76, 13, 27 //[38, 49, 65], 97, 76, 13, 27 //[38, 49, 65, 97], 76, 13, 27 //[38, 49, 65, 76, 97], 13, 27 //[13, 38, 49, 65, 76, 97], 27 //[13, 27, 38, 49, 65, 76, 97] 代码实现：
} }
4.3.1.2 插入排序之折半插入排序
算法思路：折半插入排序 (Binary insertion sort)当直接插入排序进行到某一趟时，对于 a[i]来讲，前边 i-1 个记录已经按有序。此时不用直接插入排序的方法，而改为先用折半查找 法找出 r[i]应插的位置，然后再插入。这种方法就是折半插入排序。
//利用递归实现 import java.util.*; public class Demo1 {
public static void main(String args[]) {
int iArr[] = {1, 2, 3, 4, 6, 8, 22, 44, 99, 111, 112, 116}; System.out.println("数组的所有元素为："); for(int i : iArr)
System.out.println("没有找到元素" + iNum); else
System.out.println("找到元素" + iNum + ", 下标为:" + index); }
public static int binarySearch(int[] arr, int num, int iMin, int iMax) {
System.out.println("没有找到元素" + iNum); else
System.out.println("找到元素" + iNum + ", 下标为:" + index); }
public static int straightSearch(int[] arr, int num) {
for(int j = 0; j < 10000; j++) for(int k = 0; k < 100; k++) a++;
} } 前后两次获得当前系统时间的差值就是运行所消耗的时间（毫秒为单位）。 通过 System.currentTimeMillis()方法来测试的缺点： a.不同的平台执行的时间不同 b.有些算法随着输入数据的加大，测试时间会变得不切实际！
while(iMin <= iMax) {
int iMid = (iMin + iMax) / 2; if(num == arr[iMid])
return iMid; else if(num < arr[iMid])
iMax = iMid-1; else
iMin = iMid+1; } return -1; } }
}
public static void binaryInsertSort(int a[]){
for (int i = 1; i < a.length; i++) //共进行 n-1 趟插入
{
int iTmp = a[i]; //将待插入数据临时保存到 iTmp 中去.
int m = findPosition(a, a[i], 0, i - 1); //m 是 a[i]应该呆的位置
System.out.print(i + " "); System.out.println();
System.out.print("请输入你要查找的元素："); Scanner scan = new Scanner(System.in); int iNum = scan.nextInt(); int index = binarySearch(iArr, iNum, 0, iArr.length-1); if(index == -1)
}
public static void straightInsertSort(int a[]){ int i, m; for (i = 1; i < a.length; i++) //共进行 n-1 趟插入 { m = i; while (m >= 1 && a[m] < a[m-1]) //短路表达式 { a[m] = (a[m]+a[m-1]) - (a[m-1] = a[m]); //比前一个小, 则与之交换 m--; } }
int iMid = (iMin + iMax) / 2; if (num < arr[iMin] || num > arr[iMax])
return -1; else if (num == arr[iMid])
return iMid; else if (num < arr[iMid])
return binarySearch(arr, num, iMin, iMid - 1); else
if (num < a[iMin]) return iMin; //超出范围,直接返回
if (num > a[iMax]) return iMax + 1; //超出范围,直接返回
System.out.print("请输入你要查找的元素："); Scanner scan = new Scanner(System.in); int iNum = scan.nextInt(); int index = straightSearch(iArr, iNum); if(index == -1)
System.out.println("没有找到元素" + iNum); else
System.out.println("找到元素" + iNum + ", 下标为:" + index); }
public static int binarySearch(int[] arr, int num, int iMin, int iMax) {
注意：二分查找只是针对有序排列的各种数组或集合。 实例： //不利用递归实现 import java.util.*; public class Demo1 {
public static void main(String args[]) {
int iArr[] = {1, 2, 3, 4, 6, 8, 22, 44, 99, 111, 112, 116}; System.out.println("数组的所有元素为："); for(int i : iArr)
public class Test {
从下标 1 开始
public static void main(String [] args){ int a[] = {49, 38, 65, 97, 76, 13, 27}; straightInsertSort(a); for (int i = 0; i < a.length; i++) System.out.print(a[i] + " "); System.out.println();
public static void main(String [] args){ int a[] = {49, 38, 65, 97, 76, 13, 27}; binaryInsertSort(a); for (int i = 0; i < a.length; i++) System.out.print(a[i] + " "); System.out.println();
4.1 算法
前面我们已经讲过，程序=数据结构+算法。 什么是算法？对一个现有的问题我们采取的解决过程及方法，即为算法。一个用算法 实现的程序会耗费两种资源：处理时间和内存。 算法的效率分析标准：
时间复杂度 空间复杂度 简单性和清晰性 对于时间复杂度，可以通过 System.currentTimeMillis()方法来测试。例如： public class Test {