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");
		}
		
	}

}

3.快速排序

package com.test.sort;

/*
 * 快速排序
 * 利用分治算法
 * 
 * 思想：
 * 假设i是开始索引，j是结束索引，key值开始是i位置的值
 * 从索引j往前遍历，找到第一个比key值小的位置，交换i和j的值（注意：此时key值是索引j的值）
 * 然后从索引i往后遍历，找到第一个比key值大的位置，交换i和j的值（注意：此时key值是索引i的值）
 * 这样i和j就大大缩小了范围，之后只要满足条件i<j，继续重复上面的操作
 * 到最后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));
		
	}
}