java搜索代码_专题 查找与排序的Java代码实现（一）

专题 查找与排序的Java代码实现(一)

查找(Searching)

线性查找(linear search)

属于无序查找算法，适合于存储结构为顺序存储或链接存储的线性表。

基本思想：从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。

时间复杂度：O(n)

具体代码：

//-------------------------------------------------------------------------

// Searches the specified array of objects using a linear search 线性查找

// algorithm. Returns null if the target is not found.

//-------------------------------------------------------------------------

public static Comparable linearSearch (Comparable[] data,

Comparable target) {

Comparable result = null;

int index = 0;

while (result == null && index < data.length){

if (data[index].compareTo(target) == 0)

result = data[index];

index++;

}

return result;

}

二分查找(binary search)

属于有序查找算法，元素必须是有序的，如果是无序的则要先进行排序操作。

基本思想：用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，这样递归进行，直到查找到或查找结束发现表中没有这样的结点。

时间复杂度：O(log2n)

具体代码：

//--------------------------------------------------------------------------

// Searches the specified array of objects using a binary search 二分查找

// algorithm. Returns null if the target is not found.

//--------------------------------------------------------------------------

public static Comparable BinarySearch(Comparable[] data,

Comparable target){

Comparable result = null;

int first = 0, last = data.length-1, mid;

while (result == null && first <= last){

mid = (first + last) / 2; // determine midpoint

if (data[mid].compareTo(target)==0)

result = data[mid];

else

if (data[mid].compareTo(target) == 0)

result = mid - 1;

else

first = mid + 1;

}

return result;

}

排序(Sorting)

选择排序(selection sort)

基本思想：对一个数列进行排序时，每次从剩余的序列中挑选出最小的记录，放到序列开始位置，以此类推，直到数列的所有数字都已经放到最终位置为止。

时间复杂度：O(n^2)

具体代码：

//-----------------------------------------------------------------

// Sorts the specified array of integers using the selection

// sort algorithm.

//-----------------------------------------------------------------

public static void selectionSort (Comparable[] data) {

int min;

for (int index = 0; index < data.length-1; index++) {

min = index;

for (int scan = index+1; scan < data.length; scan++)

if (data[scan].compareTo(data[min]) < 0)

min = scan;

swap (data, min, index);

}

}

//-----------------------------------------------------------------

// Swaps two elements in the specified array.

//-----------------------------------------------------------------

private static void swap (Comparable[] data, int index1, int index2)

{

Comparable temp = data[index1];

data[index1] = data[index2];

data[index2] = temp;

}

插入排序(insertion sort)

基本思想：每次从数列中取一个还没有取出过的数，并按照大小关系插入到已经取出的数中使得已经取出的数仍然有序。

时间复杂度：O(n^2)

具体代码：

//-----------------------------------------------------------------

// Sorts the specified array of objects using an insertion

// sort algorithm.

//-----------------------------------------------------------------

public static void insertionSort (Comparable[] data)

{

for (int index = 1; index < data.length; index++)

{

Comparable key = data[index];

int position = index;

// Shift larger values to the right

while (position > 0 && data[position-1].compareTo(key) > 0)

{

data[position] = data[position-1];

position--;

}

data[position] = key;

}

}

冒泡排序(bubble sort)

属于交换排序

基本思想：经过一趟冒泡排序之后，序列中最大的记录到了序列最后，而较小的记录位置均向前移动了

时间复杂度：O(n^2)

具体代码：

//-----------------------------------------------------------------

// Sorts the specified array of objects using a bubble sort

// algorithm.

//-----------------------------------------------------------------

public static void bubbleSort (Comparable[] data)

{

int position, scan;

for (position = data.length - 1; position >= 0; position--)

{

for (scan = 0; scan <= position - 1; scan++)

if (data[scan].compareTo(data[scan+1]) > 0)

swap (data, scan, scan+1);

}

}

快速排序(quick sort)

属于交换排序，快速排序是对冒泡排序的一种改进。

基本思想：将待排序序列分成两部分，其中一部分的记录都比另一部分的记录小，随后分别对这两部分再分成两部分，使一部分的记录都小于另一部分，如此反复最终使整个序列最终有序。

时间复杂度：O(n*log2n)

具体代码：

//-----------------------------------------------------------------

// Sorts the specified array of objects using the quick sort

// algorithm.

//-----------------------------------------------------------------

public static void quickSort (Comparable[] data, int min, int max)

{

int pivot;

if (min < max)

{

pivot = partition (data, min, max); // make partitions

quickSort(data, min, pivot-1); // sort left partition

quickSort(data, pivot+1, max); // sort right partition

}

}

//-----------------------------------------------------------------

// Creates the partitions needed for quick sort.

//-----------------------------------------------------------------

private static int partition (Comparable[] data, int min, int max)

{

// Use first element as the partition value

Comparable partitionValue = data[min];

int left = min;

int right = max;

while (left < right)

{

// Search for an element that is > the partition element

while (data[left].compareTo(partitionValue) <= 0 && left < right)

left++;

// Search for an element that is < the partitionelement

while (data[right].compareTo(partitionValue) > 0)

right--;

if (left < right)

swap(data, left, right);

}

// Move the partition element to its final position

swap (data, min, right);

return right;

}

归并排序(merge sort)

基本思想：重复调用归并算法，首先将单个记录视为一个有序序列，然后不断将相邻的两个有序序列合并得到新的有序序列，如此反复，最后得到一个整体有序的序列

时间复杂度：O(n*log2n)

具体代码：

//-----------------------------------------------------------------

// Sorts the specified array of objects using the merge sort

// algorithm.

//-----------------------------------------------------------------

public static void mergeSort (Comparable[] data, int min, int max)

{

if (min < max)

{

int mid = (min + max) / 2;

mergeSort (data, min, mid);

mergeSort (data, mid+1, max);

merge (data, min, mid, max);

}

}

//-----------------------------------------------------------------

// Sorts the specified array of objects using the merge sort

// algorithm.

//-----------------------------------------------------------------

public static void merge (Comparable[] data, int first, int mid,

int last)

{

Comparable[] temp = new Comparable[data.length];

int first1 = first, last1 = mid; // endpoints of first subarray

int first2 = mid+1, last2 = last; // endpoints of second subarray

int index = first1; // next index open in temp array

// Copy smaller item from each subarray into temp until one

// of the subarrays is exhausted

while (first1 <= last1 && first2 <= last2)

{

if (data[first1].compareTo(data[first2]) < 0)

{

temp[index] = data[first1];

first1++;

}

else

{

temp[index] = data[first2];

first2++;

}

index++;

}

// Copy remaining elements from first subarray, if any

while (first1 <= last1)

{

temp[index] = data[first1];

first1++;

index++;

}

// Copy remaining elements from second subarray, if any

while (first2 <= last2)

{

temp[index] = data[first2];

first2++;

index++;

}

// Copy merged data into original array

for (index = first; index <= last; index++)

data[index] = temp[index];

}