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

Java七种排序算法教程

Java七种排序算法教程
  • javaniuniu
  • javaniuniu
  • 2017年04月06日 12:55
  • 264

二分查找、快速排序对比和详解

**二分查找和快速排序(binarySearch)&&(quickSort)** 这两个都是用到分治的思想很容易搞混。而且即使binarySearch是用到分治到不一定意味着递归可以通过循环实现。而且...
  • qhrqhrqhr
  • qhrqhrqhr
  • 2016年03月24日 22:19
  • 2572

查找算法(二叉搜索树查找,二分查找,hash查找)

这个是在链表基础上根据实验内容然后添加了一个二分查找的功能: 二分查找在竞赛极其开发中极其有用,尤其是二分的思想!!! [cpp] view plain copy print? usin...
  • lsgqjh
  • lsgqjh
  • 2016年07月12日 12:58
  • 835

LeetCode 69: Sqrt(x) 求根号x(牛顿迭代法和二分查找法)

题目: Implement int sqrt(int x). Compute and return the square root of x.分析:我们平常可能好少会自己去求解某个数的平方根,一般...
  • hnu2012
  • hnu2012
  • 2017年05月21日 13:54
  • 792

二分查找求上界和下界

二分查找求上界和下界假设序列有序,其区间为[left,right)[left, right),设middlemiddle为区间中间值,现在需要获得首个出现元素vv的位置,如果不存在,返回一个位置,在此...
  • q547550831
  • q547550831
  • 2016年05月30日 12:21
  • 1730

java常用的8种排序算法

分类: 1)插入排序(直接插入排序、希尔排序) 2)交换排序(冒泡排序、快速排序) 3)选择排序(直接选择排序、堆排序) 4)归并排序 5)分配排序(基数排序) 所需辅助空间最多:归并排序...
  • qq_37723158
  • qq_37723158
  • 2018年01月09日 19:18
  • 44

排序算法合集(Java)

整理了一下常用的排序算法,算法过程和示意图不详细讲,百度很多,只列代码,如有错误,还望大家指出。 1.冒泡排序public static void bubbleSort(int[] a){ ...
  • maydaysar
  • maydaysar
  • 2017年03月11日 10:41
  • 110

二分查找各种情况大总结

二分查找多次刷题时遇到,虽然每次也能写对,但花了蛮多时间,没好好想过。而且网上的太多版本,并不是很简洁,而且边界条件变化情况太多,容易混淆,下面是自己对二分查找的一些思考和总结,尽量写得简单易懂。 ...
  • yefengzhichen
  • yefengzhichen
  • 2016年08月30日 21:40
  • 12321

二分查找的递归和非递归写法

二分查找是针对有序序列来说的,在有序序列中使用二分查找能大大提高查找效率,这里记录一下二分查找的递归和非递归写法。非递归写法:public int binarySearch(int[] a, int ...
  • buptwds
  • buptwds
  • 2016年07月18日 18:21
  • 801

顺序查找,二分查找,哈希查找

查找 1.顺序查找 (1)适用于顺序表,链表。 (2)方法:在某个数据集合中,从第一个数据元素开始,依次向后查找。 i>顺序表的实现 Int  search (int a [ ],  int  n ,...
  • Smallsun_229
  • Smallsun_229
  • 2014年10月31日 08:05
  • 742
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java排序算法和二分查找
举报原因:
原因补充:

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