常见算法的记录

标签：

快速排序

时间复杂度 O(n*log₂n)

总结起来，快排的核心算法只有两步：

1）sort排序函数中，调用分区函数partition，将大的数组分成两块，然后再分别调用sort函数，这是一个递归过程。

2）partition分区函数

public class QSort {

	public static void main(String[] args) {
		quicksort qs = new quicksort();
		int data[] = { 44, 22, 2, 32, 54, 22, 88, 77, 99, 11 };
		qs.data = data;
		qs.sort(0, qs.data.length - 1);
		qs.display();
	}

}

class quicksort {
	public int data[];

	private int partition(int sortArray[], int low, int hight) {
		int key = sortArray[low];

		while (low < hight) {
			while (low < hight && sortArray[hight] >= key)
				hight--;
			sortArray[low] = sortArray[hight];

			while (low < hight && sortArray[low] <= key)
				low++;
			sortArray[hight] = sortArray[low];
		}
		sortArray[low] = key;
		return low;
	}

	public void sort(int low, int hight) {
		if (low < hight) {
			int result = partition(data, low, hight);
			sort(low, result - 1);
			sort(result + 1, hight);
		}

	}

	public void display() {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i]);
			System.out.print(" ");
		}
	}
}

二分查找算法

public class BinarySearch {
	private int rCount=0;
	private int lCount=0;
	
	/**
	 * 获取递归的次数
	 * @return
	 */
	public int getrCount() {
		return rCount;
	}

	/**
	 * 获取循环的次数
	 * @return
	 */
	public int getlCount() {
		return lCount;
	}

	/**
	 * 执行递归二分查找，返回第一次出现该值的位置
	 * @param sortedData	已排序的数组
	 * @param start			开始位置
	 * @param end			结束位置
	 * @param findValue		需要找的值
	 * @return				值在数组中的位置，从0开始。找不到返回-1
	 */
	public int searchRecursive(int[] sortedData,int start,int end,int findValue)
	{
		rCount++;
		if(start<=end)
		{
			//中间位置
			int middle=(start+end)>>1;	//相当于(start+end)/2
			//中值
			int middleValue=sortedData[middle];
			
			if(findValue==middleValue)
			{
				//等于中值直接返回
				return middle;
			}
			else if(findValue<middleValue)
			{
				//小于中值时在中值前面找
				return searchRecursive(sortedData,start,middle-1,findValue);
			}
			else
			{
				//大于中值在中值后面找
				return searchRecursive(sortedData,middle+1,end,findValue);
			}
		}
		else
		{
			//找不到
			return -1;
		}
	}
	
	/**
	 * 循环二分查找，返回第一次出现该值的位置
	 * @param sortedData	已排序的数组
	 * @param findValue		需要找的值
	 * @return				值在数组中的位置，从0开始。找不到返回-1
	 */
	public int searchLoop(int[] sortedData,int findValue)
	{
		int start=0;
		int end=sortedData.length-1;
		
		while(start<=end)
		{
			lCount++;
			//中间位置
			int middle=(start+end)>>1;	//相当于(start+end)/2
			//中值
			int middleValue=sortedData[middle];
			
			if(findValue==middleValue)
			{
				//等于中值直接返回
				return middle;
			}
			else if(findValue<middleValue)
			{
				//小于中值时在中值前面找
				end=middle-1;
			}
			else
			{
				//大于中值在中值后面找
				start=middle+1;
			}
		}
		//找不到
		return -1;
	}
}

public class BinarySearchTest {  
	public static void main(String[] args) {
		BinarySearch bs=new BinarySearch();  
        
        int[] sortedData={1,2,3,4,5,6,6,7,8,8,9,10};  
        int findValue=9;  
        int length=sortedData.length;  
          
        int pos=bs.searchRecursive(sortedData, 0, length-1, findValue);  
        System.out.println("Recursice:"+findValue+" found in pos "+pos+";count:"+bs.getrCount());  
        int pos2=bs.searchLoop(sortedData, findValue);  
          
        System.out.println("Loop:"+findValue+" found in pos "+pos+";count:"+bs.getlCount());  
	}
}

常见算法的记录

标签：

原文地址：http://my.oschina.net/gaohongtian/blog/494880