看到網上的一段關於對數組操作的代碼
import java
import java
import java
import java
import java
import java
/**
* @desc 數組操作工具
* @author OuyangPeng
* @datatime
*
*/
public class MyArrayUtils {
/**
* 排序算法的分類如下
*
*
* 關於排序方法的選擇
* (
* (
*
*/
/**
* 交換數組中兩元素
*
* @since
* @param ints
* 需要進行交換操作的數組
* @param x
* 數組中的位置
* @param y
* 數組中的位置
* @return 交換後的數組
*/
public static int[] swap(int[] ints
int temp = ints[x];
ints[x] = ints[y];
ints[y] = temp;
return ints;
}
/**
* 冒泡排序方法:相鄰兩元素進行比較 性能
* 冒泡排序(Bubble Sort)是一種簡單的排序算法
* 如果他們的順序錯誤就把他們交換過來
* 也就是說該數列已經排序完成
冒泡排序算法的運作如下:
* @since
* @param source
* 需要進行排序操作的數組
* @return 排序後的數組
*/
public static int[] bubbleSort(int[] source) {
/*for (int i =
for (int j =
if (source[j] > source[j +
swap(source
}
}
}*/
for (int i = source
for (int j =
if (source[j] > source[j +
swap(source
}
}
}
return source;
}
/**
* 選擇排序法 方法
* 它的工作原理如下
* 再從剩余未排序元素中繼續尋找最小元素
* 性能
* 選擇排序的賦值操作介於
* 交換次數比冒泡排序少多了
* 但是N比較大時
*
* @since
* @param source
* 需要進行排序操作的數組
* @return 排序後的數組
*/
public static int[] selectSort(int[] source) {
for (int i =
for (int j = i +
if (source[i] > source[j]) {
swap(source
}
}
}
return source;
}
/**
* 插入排序 方法
* 復制次數O(n)
*
* @since
* @param source
* 需要進行排序操作的數組
* @return 排序後的數組
*/
public static int[] insertSort(int[] source) {
for (int i =
for (int j = i; (j >
swap(source
}
}
return source;
}
/**
* 快速排序 快速排序使用分治法(Divide and conquer)策略來把一個序列(list)分為兩個子序列(sub
*
* 重新排序數列
* (相同的數可以到任一邊)
* 遞歸地(recursive)把小於基准值元素的子數列和大於基准值元素的子數列排序
* 遞回的最底部情形
*
*
* @since
* @param source
* 需要進行排序操作的數組
* @return 排序後的數組
*/
public static int[] quickSort(int[] source) {
return qsort(source
}
/**
* 快速排序的具體實現
*
* @since
* @param source
* 需要進行排序操作的數組
* @param low
* 開始低位
* @param high
* 結束高位
* @return 排序後的數組
*/
private static int[] qsort(int source[]
int i
if (low < high) {
i = low;
j = high;
x = source[i];
while (i < j) {
while (i < j && source[j] > x) {
j
}
if (i < j) {
source[i] = source[j];
i++;
}
while (i < j && source[i] < x) {
i++;
}
if (i < j) {
source[j] = source[i];
j
}
}
source[i] = x;
qsort(source
qsort(source
}
return source;
}
// /////////////////////////////////////////////
// 排序算法結束
// ////////////////////////////////////////////
/**
* 二分法查找 查找線性表必須是有序列表
*
* @since
* @param source
* 需要進行查找操作的數組
* @return 需要查找的值在數組中的位置
*/
public static int[] binarySearch(int[] source) {
int i
int low
int temp;
for (i =
temp=source[i];
low=
high=i
while (low <= high) {
mid = (low + high)/
if (source[mid]>temp) {
high=mid
} else {
low = mid +
}
}
for (j= i
source[j+
source[high+
}
return source;
}
/**
* 反轉數組
*
* @since
* @param source
* 需要進行反轉操作的數組
* @return 反轉後的數組
*/
public static int[] reverse(int[] source) {
int length = source
int temp =
for (int i =
temp = source[i];
source[i] = source[length
source[length
}
return source;
}
/**
* 在當前位置插入一個元素
*
* @param array
* @param index
* @param insertNumber
* @return
*/
public static int[] insert(int[] array
if (array == null || array
throw new IllegalArgumentException();
}
if (index
throw new IllegalArgumentException();
}
int[] dest = new int[array
System
dest[index
System
return dest;
}
/**
* 整形數組中特定位置刪除掉一個元素
*
* @param array
* @param index
* @return
*/
public static int[] remove(int[] array
if (array == null || array
throw new IllegalArgumentException();
}
if (index > array
throw new IllegalArgumentException();
}
int[] dest = new int[array
System
System
return dest;
}
/**
*
*
* @param array
* @param array
* @return
*/
public static int[] merge(int[] array
int[] dest = new int[array
System
System
return dest;
}
/**
* 數組中有n個數據
* 例如
*
* @param array
* @param offset
* @return
*/
public static int[] offsetArray(int[] array
int length = array
int moveLength = length
int[] temp = pyOfRange(array
System
System
return array;
}
/**
* 隨機打亂一個數組
*
* @param list
* @return
*/
public static List shuffle(List list) {
java
return list;
}
/**
* 隨機打亂一個數組
*
* @param array
* @return
*/
public int[] shuffle(int[] array) {
Random random = new Random();
for (int index = array
// 從
exchange(array
}
return array;
}
// 交換位置
private void exchange(int[] array
int temp = array[p
array[p
array[p
}
/**
* 對兩個有序數組進行合並
*
* @param a
*
* @param b
*
* @return 合並後的排序數組
*/
private static List mergeByList(int[] a
// 用於返回的新數組
List c = new ArrayList();
// a數組下標
int aIndex =
// b數組下標
int bIndex =
// 對a
// 如果相等
// 如果下標超出該數組長度
while (true) {
if (aIndex > a
break;
}
if (a[aIndex] < b[bIndex]) {
c
aIndex++;
} else if (a[aIndex] > b[bIndex]) {
c
bIndex++;
} else {
c
aIndex++;
bIndex++;
}
}
// 將沒有超出數組下標的數組其余全部加到數組c中
// 如果a數組還有數字沒有處理
if (aIndex <= a
for (int i = aIndex; i <= a
c
}
// 如果b數組中還有數字沒有處理
} else if (bIndex <= b
for (int i = bIndex; i <= b
c
}
}
return c;
}
/**
* 對兩個有序數組進行合並
*
* @param a
* :已排好序的數組a
* @param b
* :已排好序的數組b
* @return合並後的排序數組
*/
private static int[] mergeByArray(int[] a
int[] c = new int[a
int i =
while (i < a
if (a[i] <= b[j]) {
if (a[i] == b[j]) {
j++;
} else {
c[k] = a[i];
i++;
k++;
}
} else {
c[k] = b[j];
j++;
k++;
}
}
while (i < a
c[k] = a[i];
k++;
i++;
}
while (j < b
c[k] = b[j];
j++;
k++;
}
return c;
}
/**
* 對兩個有序數組進行合並
*
* @param a
*
* @param b
*
* @return合並後的排序數組 打印時可以這樣
* Iterator iterator = map
* (iterator
* (Map
* System
*/
private static Map mergeByTreeMap(int[] a
Map map = new TreeMap();
for (int i =
map
}
for (int i =
map
}
return map;
}
/**
* 在控制台打印數組
*
* @param array
*/
public static String print(int[] array) {
StringBuffer sb = new StringBuffer();
for (int i =
sb
}
System
return sb
}
}
From:http://tw.wingwit.com/Article/program/Java/hx/201311/26760.html