Java排序算法和二分查找

原创 2013年12月03日 21:14:16
package Bean;

public class Sort {

	static int nElement = 0;
	int[] arr;

	public Sort(int max) {
		arr = new int[max];
	}

	public void insert(int a) {
		arr[nElement] = a;
		nElement++;
	}

	// 冒泡排序
	public void bubbleSort() {
		int out, i;
		for (out = nElement - 1; out > 1; out--) {
			for (i = 0; i < out; i++) {
				if (arr[i] > arr[i + 1]) {
					swap(i, i + 1);
				}
			}

		}
	}

	// 选择排序
	public void selectSort() {
		int in, out;
		for (out = 0; out < nElement - 1; out++) {
			for (in = out + 1; in < nElement; in++) {
				if (arr[in] < arr[out]) {
					swap(in, out);
				}
			}
		}
	}

	// 插入排序
	public void insertSort() {
		for (int i = 1; i < nElement; i++) {
			int imterval = arr[i];
			int index = i - 1;

			while (index >= 0 && arr[index] > imterval) {
				arr[index + 1] = arr[index];
				index--;
			}
			arr[index + 1] = imterval;
		}
	}

	// 快速排序
	public void quickSort() {
		recQuickSort(0, nElement - 1);

	}

	public void recQuickSort(int left, int right) {
		int size = right - left +1;
		if (size <= 3) {
			manualSort(left, right);
		} else {
			int median = medianGet(left, right);
			int partition = partitionIt(left, right, median);
			recQuickSort(0, partition - 1);
			recQuickSort(partition, right);
		}
		
	}

	public int partitionIt(int left, int right, int median) {
		int leftPtr = left;
		int rightPtr = right - 1;
		while (true) {
			while (arr[++leftPtr] < median)
				;
			while (arr[--rightPtr] > median)
				;
			if (leftPtr >= rightPtr) {
				break;
			} else {
				swap(leftPtr, rightPtr);
			}
		}
		return leftPtr;
	}

	public void manualSort(int left, int right) {
		int size = right - left +1;
		if (size == 1)
			return;
		if (size == 2) {
			if (arr[left] > arr[right]) {
				swap(left, right);
			}
			return;
		} else {
			if (arr[left] > arr[right - 1]) {
				swap(left, right - 1);
			}
			if (arr[left] > arr[right]) {
				swap(left, right);
			}
			if (arr[right - 1] > arr[right]) {
				swap(right - 1, right);
			}
		}
	}

	public int medianGet(int left, int right) {
		int center = (left + right) / 2;
		if (arr[left] > arr[center]) {
			swap(left, center);
		}
		if (arr[left] > arr[right]) {
			swap(left, right);
		}
		if (arr[center] > arr[right]) {
			swap(center, right);
		}
		swap(center, right);
		return arr[right];
	}

	// 希尔排序
	public void shellSort(){
		int h = 1;
		int in, out;
		while(h <= nElement/3){
			h = h*3 + 1;
		}
		while(h > 0){
			for (out = h; out < nElement; out++){
				int temp = arr[out];
				in = out;
				while(in > h - 1 && arr[in - h] > temp){
					arr[in] = arr[in - h];
					in = in - h;
				}
				arr[in] = temp;
			}
			h = (h - 1)/3;
		}
	}
	
	// 二分查找
	public int binSearch(int start,int end, int key){
		int mid = (end - start) / 2 + start;
		if(arr[mid] == key)return mid;
		if(arr[mid] > key){
			return binSearch(start, mid, key);
		} else if(arr[mid] < key){
			return binSearch(mid, end, key);
		} 
		return 0;
	}
	
	
	// 汉诺塔
	public static void doTower(int nDisk,char from, char inter, char to){
		if(nDisk == 1){
			System.out.println("Disk 1 from " + from  + " to: " + to);
		}else {
			doTower(nDisk - 1, from, to, inter);
			System.out.println("Disk " + nDisk + " from " + from  + " to: " + to);
			doTower(nDisk - 1, inter, from, to);
		}
	}
	
	// 归并排序
	public void mergeSort(){
		int[] workArr = new int[nElement];
		recMergeSort(workArr,0, nElement - 1);
	}
	
	public void recMergeSort(int[] workArr, int low, int high){
		if(low == high){
			return;
		} else {
			int mid = (high + low)/2;
			recMergeSort(workArr, low, mid);
			recMergeSort(workArr, mid + 1 , high);
			merge(workArr, low, mid + 1, high);
		}
	}
	
	public void merge(int[] workArr, int low, int high, int upper){
		int mid = high - 1;
		int j = 0;
		int lowBound = low;
		int n = upper - lowBound + 1;
		 while(low <= mid && high <= upper){
			 if(arr[low] < arr[high]){
				 workArr[j++] = arr[low++];
			 } else{
				 workArr[j++] = arr[high++];
			 }
		 }
		 while(low <= mid){
			 workArr[j++] = arr[low++];
		 }
		 while(high <= upper){
			 workArr[j++] = arr[high++];
		 }
		 for(j = 0; j < n; j++){
			 arr[lowBound+j] = workArr[j];
		 }
	}
	
	public void swap(int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	public void displace() {
		for (int i = 0; i < nElement; i++) {
			System.out.print(arr[i] + " ");
		}
	}

	public static void main(String args[]) {
		Sort sort = new Sort(7);
		sort.insert(24);
		sort.insert(3);
		sort.insert(18);
		sort.insert(11);
		sort.insert(65);
		sort.insert(5);
		sort.insert(29);

		sort.mergeSort();
//		int src = sort.binSearch(0, nElement, 11);
//		System.out.println(src);
		sort.displace();
//		doTower(3, 'A', 'B', 'C');
	}
}

相关文章推荐

二分查找算法和冒泡排序算法

  • 2015年04月22日 11:27
  • 942KB
  • 下载

基础排序算法与二分查找算法Java版本(下)

/** * Created by Alvin on 15/11/11. */ public class Sort {public static void swap(int[] temp ,i...

二分查找和排序算法

《Algorithms Unlocked》是 《算法导论》的合著者之一 Thomas H. Cormen 写的一本算法基础,算是啃CLRS前的开胃菜和辅助教材。如果CLRS的厚度让人望而生畏,这本20...

排序算法--折半插入排序(二分查找排序)

? 折半插入排序其实就是直接插入排序的一种改进,引入了二分查找算法,这样关键字的比较次数就会减少, 数量级为O(nlog^2n),但是元素移动次数还是O(n^2),所以折半插入排序的时间复...

排序算法之带二分查找的插入排序

带二分查找的插入排序要借助3个游标,low mid high来确定temp这个要插入的新元素的位置,在lowtemp的时候就说明temp在mid的左边,即把high改成mid,因为mid此时一定大于t...

基础排序算法总结(插入、选择、冒泡、合并、二分查找、堆排序、快速排序、基数排序、桶排序、计数排序)

本文是在学习《算法导论》的基础排序算法过程中,自己写的Java代码,深入掌握思想,并且有能力实现,并且分析其复杂度。本文对于每一个算法,按照算法思想、伪代码、Java实现、复杂度简单分析的方式分析每一...

java简单算法(二分查找 冒泡排序 判断是否为素数)

递归实现:public static int binarySearch(int[] arr, int data, int beginIndex, int endIndex) { int midIn...

Java数据结构算法之选择排序、插入排序、冒泡排序、二分查找

/*其实个人感觉算法的好处在于思想,代码神马的都是浮云,有了算法思想代码都是水到渠成的事,不理解这种思想,看算法类代码就跟一坨屎是一样一样的,没什么可阅读的。浪费时间,一般程序员不是专门搞算法的其实实...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java排序算法和二分查找
举报原因:
原因补充:

(最多只允许输入30个字)