java内置查找排序算法_java语言实现常用算法（排序和查找）

以下是java语言实现的常用算法：

1.冒泡排序

/*

* 冒泡排序

*

* 有1至N个数

* 第一轮比较N个数，第二轮比较N-1个数，...

* 每一轮根据前面一个数和后面一个数比较，如果前者大于后者，交换位置。

* 这样第一轮比较后第N个数是第一大数，第二轮比较后第N-1个数是第二大数，...

*/

public class BubbleSort

{

//bubble sort

public static void sort(int[] a)

{

int i, j;

int swap;

for(i = a.length - 1; i > 0; i--)

{

for(j = 0; j < i; j++)

{

if(a[j] > a[j + 1])

{

swap = a[j];

a[j] = a[j + 1];

a[j + 1] = swap;

}

}

}

}

public static void main(String[] args)

{

int[] a = {46, 58, 15, 45, 90, 18, 10, 62};

BubbleSort.sort(a);

for(int i = 0; i < a.length; i++)

{

System.out.print(a[i]+"\t");

}

}

}

2.插入排序

package com.test.sort;

/*

* 插入排序

*

* 有1至N个数

* 从第二个数开始进行N-1轮比较

* 如：在第n轮比较中，这里假设是第3个数，

* 先把第3个数赋值给num，索引号赋值给j，

* 之后num先和第2个数比较，小于的话就把第2个数赋值给第3个位置，

* num再和第1个数比较，小于的话就把第1个数赋值给第2个位置，

* 最后num赋值给第1个位置。

*/

public class InsertSort

{

//insert sort

public static void sort(int[] array)

{

int j;

int num;

for(int i = 1; i < array.length; i++)

{

num = array[i];

j = i;

while(j > 0 && num < array[j - 1])

{

array[j] = array[j - 1];

j--;

}

array[j] = num;

}

}

public static void main(String[] args)

{

int[] a = {46, 58, 15, 45, 90, 18, 10, 62};

InsertSort.sort(a);

for(int i = 0; i < a.length; i++)

{

System.out.print(a[i]+"\t");

}

//int[] a = { 46, 58, 15, 45, 90, 18, 10, 62 };

//int n = a.length;

//int i, j;

//for (i = 0; i < n; i++) {

//int temp = a[i];

//for (j = i; j > 0 && temp < a[j-1]; j--) {

//a[j] = a[j - 1];

//}

//a[j] = temp;

//}

//

//for(i=0;i

//System.out.print(a[i]+"\t");

//}

}

}

3.快速排序

package com.test.sort;

/*

* 快速排序

* 利用分治算法

*

* 思想：

* 假设i是开始索引，j是结束索引，key值开始是i位置的值

* 从索引j往前遍历，找到第一个比key值小的位置，交换i和j的值(注意：此时key值是索引j的值)

* 然后从索引i往后遍历，找到第一个比key值大的位置，交换i和j的值(注意：此时key值是索引i的值)

* 这样i和j就大大缩小了范围，之后只要满足条件i

* 到最后i=j时，此时当前索引前面的数值都比key值小，索引后面的数值都比key值大

*

* 最后一步是调用递归：

* 根据最后的索引i作为分割点，如：start ~ i-1，i+1 ~ end

* 继续上面的操作

*/

public class QuickSort

{

//quick sort

public static void sort(int[] a, int start, int end)

{

int i, j;

int temp;

i = start;

j = end;

if(a == null || a.length == 0)

{

return;

}

while(i < j)

{

while(i < j && a[i] <= a[j])

{

j--;

}

if( i < j)

{

temp = a[j];

a[j] = a[i];

a[i] = temp;

}

while(i < j && a[i] < a[j])

{

i++;

}

if( i < j)

{

temp = a[j];

a[j] = a[i];

a[i] = temp;

}

}

if(i - start > 1)

{

sort(a, start, i - 1);

}

if(end - i > 1)

{

sort(a, i + 1, end);

}

}

public static void main(String[] args)

{

int[] a = {46, 58, 15, 45, 90, 18, 10, 62};

QuickSort.sort(a, 0, a.length - 1);

for(int i = 0; i < a.length; i++)

{

System.out.print(a[i]+"\t");

}

}

}

4.选择排序

package com.test.sort;

public class SelectSort

{

//select sort

public static void sort(int[] a)

{

int i, j;

int minVal, minIndex = 0;

for(i = 0; i < a.length; i++)

{

minVal = a[i];

for(j = i; j < a.length; j++)

{

if(a[j] <= minVal)

{

minVal = a[j];

minIndex = j;

}

}

a[minIndex] = a[i];

a[i] = minVal;

}

}

public static void main(String[] args)

{

int[] a = {46, 58, 15, 45, 90, 18, 10, 62};

SelectSort.sort(a);

for(int i = 0; i < a.length; i++)

{

System.out.print(a[i]+"\t");

}

}

}

-----------------------------------------------------------

5.二分查找

package com.test.search;

public class BinarySearch

{

public static int search(int[] a, int b)

{

int start = 0;

int end = a.length - 1;

while(start <= end)

{

//int middle = start + ((end - start)>>>1);

int middle = (start + end) / 2;

if(b == a[middle])

{

return middle;

}

else if(b < a[middle])

{

end = middle -1;

}

else

{

start = middle + 1;

}

}

return -1;

}

public static void main(String[] args)

{

int[] a = {2, 5, 10, 23, 50, 55, 68, 80, 88, 95, 100};

System.out.println(BinarySearch.search(a, 80));

}

}