org.oiue.tools.arrays

Class ArrayUtil

java.lang.Object

org.oiue.tools.arrays.ArrayUtil

public class ArrayUtil
extends Object

ArrayUtil.java 数组操作工具

Author:

Guoxp Apr 7, 2013 4:03:49 PM

Constructor Summary

Constructors

Constructor and Description
ArrayUtil()

Method Summary

Modifier and Type	Method and Description
static int	binarySearch(int[] source, int key) 二分法查找 查找线性表必须是有序列表
static int[]	bubbleSort(int[] source) 冒泡排序 方法：相邻两元素进行比较 性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4
static int	indexOf(byte[] s, byte[] value, int index)
static int	indexOf(byte[] s, byte value, int index) 首次出现的位置
static int[]	insert(int[] array, int index, int insertNumber) 在当前位置插入一个元素,数组中原有元素向后移动; 如果插入位置超出原数组，则抛IllegalArgumentException异常
static int[]	insertSort(int[] source) 插入排序 方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。 性能：比较次数O(n^2),n^2/4 复制次数O(n),n^2/4 比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
static int[]	merge(int[] array1, int[] array2) 2个数组合并，形成一个新的数组
static int[]	offsetArray(int[] array, int offset) 数组中有n个数据，要将它们顺序循环向后移动k位， 即前面的元素向后移动k位，后面的元素则循环向前移k位， 例如，0、1、2、3、4循环移动3位后为2、3、4、0、1。
static String	print(int[] array) 在控制台打印数组，之间用逗号隔开,调试时用
static int[]	quickSort(int[] source) 快速排序 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。 步骤为： 1.
static int[]	remove(int[] array, int index) 整形数组中特定位置删除掉一个元素,数组中原有元素向前移动; 如果插入位置超出原数组，则抛IllegalArgumentException异常
static int[]	reverse(int[] source) 反转数组
static int	searchOf(byte[] s, byte value, int index) 查找个数
static int[]	selectSort(int[] source) 直接选择排序法 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 性能：比较次数O(n^2),n^2/2 交换次数O(n),n 交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。 但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。
int[]	shuffle(int[] array) 随机打乱一个数组
static List	shuffle(List list) 随机打乱一个数组
static int[]	swap(int[] ints, int x, int y) 交换数组中两元素

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ArrayUtil

public ArrayUtil()

Method Detail

swap

public static int[] swap(int[] ints,
                         int x,
                         int y)

交换数组中两元素

Parameters:

ints - 需要进行交换操作的数组

x - 数组中的位置1

y - 数组中的位置2

Returns:

交换后的数组

bubbleSort

public static int[] bubbleSort(int[] source)

冒泡排序 方法：相邻两元素进行比较 性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4

Parameters:

source - 需要进行排序操作的数组

Returns:

排序后的数组

selectSort

public static int[] selectSort(int[] source)

直接选择排序法 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 性能：比较次数O(n^2),n^2/2 交换次数O(n),n 交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。 但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。

Parameters:

source - 需要进行排序操作的数组

Returns:

排序后的数组

insertSort

public static int[] insertSort(int[] source)

插入排序 方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。 性能：比较次数O(n^2),n^2/4 复制次数O(n),n^2/4 比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。

Parameters:

source - 需要进行排序操作的数组

Returns:

排序后的数组

quickSort

public static int[] quickSort(int[] source)

快速排序 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。 步骤为： 1. 从数列中挑出一个元素，称为 "基准"（pivot）， 2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面 （相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。 3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。 递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了 。虽然一直递回下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

Parameters:

source - 需要进行排序操作的数组

Returns:

排序后的数组

binarySearch

public static int binarySearch(int[] source,
                               int key)

二分法查找 查找线性表必须是有序列表

Parameters:

source - 需要进行查找操作的数组

key - 需要查找的值

Returns:

需要查找的值在数组中的位置，若未查到则返回-1

reverse

public static int[] reverse(int[] source)

反转数组

Parameters:

source - 需要进行反转操作的数组

Returns:

反转后的数组

insert

public static int[] insert(int[] array,
                           int index,
                           int insertNumber)

在当前位置插入一个元素,数组中原有元素向后移动; 如果插入位置超出原数组，则抛IllegalArgumentException异常

Parameters:

array - 数组

index - 下标

insertNumber - 插入数量

Returns:

数组

remove

public static int[] remove(int[] array,
                           int index)

整形数组中特定位置删除掉一个元素,数组中原有元素向前移动; 如果插入位置超出原数组，则抛IllegalArgumentException异常

Parameters:

array - 数组

index - 下标

Returns:

数组

merge

public static int[] merge(int[] array1,
                          int[] array2)

2个数组合并，形成一个新的数组

Parameters:

array1 - 数组

array2 - 数组

Returns:

数组

offsetArray

public static int[] offsetArray(int[] array,
                                int offset)

数组中有n个数据，要将它们顺序循环向后移动k位， 即前面的元素向后移动k位，后面的元素则循环向前移k位， 例如，0、1、2、3、4循环移动3位后为2、3、4、0、1。

Parameters:

array - 数组

offset - 位数

Returns:

操作后的数组

shuffle

public static List shuffle(List list)

随机打乱一个数组

Parameters:

list - 打乱集合

Returns:

集合

shuffle

public int[] shuffle(int[] array)

随机打乱一个数组

Parameters:

array - 数组

Returns:

打乱后的数组

print

public static String print(int[] array)

在控制台打印数组，之间用逗号隔开,调试时用

Parameters:

array - 数组

Returns:

转换

searchOf

public static int searchOf(byte[] s,
                           byte value,
                           int index)

查找个数

Parameters:

s - 原始对象

value - 查找值

index - 起始下标

Returns:

次数

indexOf

public static int indexOf(byte[] s,
                          byte value,
                          int index)

首次出现的位置

Parameters:

s - 原始对象

value - 查找值

index - 起始下标

Returns:

位置

indexOf

public static int indexOf(byte[] s,
                          byte[] value,
                          int index)