关闭

常见经典排序算法的java实现

标签: java排序算法
470人阅读 评论(0) 收藏 举报
分类:

public class Sort {
	// =======================选择排序Begin========================
	void select_sort(int[] array) {

		for (int i = 0; i < array.length - 1; i++) {
			int minIndex = i;

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

				if (array[minIndex] > array[j]) {
					minIndex = j;
				}
			}

			if (minIndex != i) {
				int temp = array[minIndex];
				array[minIndex] = array[i];
				array[i] = temp;
			}
		}
	}

	// =======================选择排序End===========================
	// =======================冒泡排序——大泡下沉Begin=============
	void bubble_sort(int[] array) {

		for (int i = array.length - 1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				int temp = 0;
				if (array[j] > array[j + 1]) {
					temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
	}

	// ======================冒泡排序——大泡下沉End================
	// ======================冒泡排序——小泡上浮Begin==============
	void bubbleSort(int[] array) {

		for (int i = 0; i < array.length; i++) {
			for (int j = array.length - 1; j > i; j--) {
				int temp = 0;
				if (array[j] < array[j - 1]) {
					temp = array[j];
					array[j] = array[j - 1];
					array[j - 1] = temp;
				}
			}
		}
	}

	// ======================冒泡排序——小泡上浮End================
	// ======================直接插入排序Begin======================
	void insertion_sort(int[] unsorted) {
		for (int i = 1; i < unsorted.length; i++) {
			if (unsorted[i - 1] > unsorted[i]) {
				int temp = unsorted[i];
				int j = i;
				while (j > 0 && unsorted[j - 1] > temp) {
					unsorted[j] = unsorted[j - 1];
					j--;
				}
				unsorted[j] = temp;
			}
		}
	}

	// =======================直接插入排序End======================

	// ========================快速排序1Begin======================
	int partition(int[] unsorted, int low, int high) {

		int pivot = unsorted[low];

		while (low < high) {

			while (low < high && unsorted[high] > pivot)
				high--;

			unsorted[low] = unsorted[high];

			while (low < high && unsorted[low] <= pivot)
				low++;

			unsorted[high] = unsorted[low];
		}

		unsorted[low] = pivot;

		return low;
	}

	void quick_sort(int[] unsorted, int low, int high) {

		int loc = 0;

		if (low < high) {

			loc = partition(unsorted, low, high);

			quick_sort(unsorted, low, loc - 1);

			quick_sort(unsorted, loc + 1, high);
		}
	}

	// =======================快速排序1End========================

	// =======================快速排序2Begin======================

	// 快速排序一次划分
	int Partition(int r[], int first, int end) {
		int i = first; // 初始化
		int j = end;
		int temp;

		while (i < j) {
			while (i < j && r[i] <= r[j])
				j--; // 右侧扫描
			if (i < j) {
				temp = r[i]; // 将较小记录交换到前面
				r[i] = r[j];
				r[j] = temp;
				i++;
			}
			while (i < j && r[i] <= r[j])
				i++; // 左侧扫描
			if (i < j) {
				temp = r[j];
				r[j] = r[i];
				r[i] = temp; // 将较大记录交换到后面
				j--;
			}
		}
		return i; // i为轴值记录的最终位置
	}

	// 快速排序
	void QuickSort(int r[], int first, int end) {
		if (first < end) { // 递归结束
			int pivot = Partition(r, first, end); // 一次划分
			QuickSort(r, first, pivot - 1); // 递归地对左侧子序列进行快速排序
			QuickSort(r, pivot + 1, end); // 递归地对右侧子序列进行快速排序
		}

	}

	// =======================快速排序2End========================

	// =======================堆排序1Begin========================
	// array是待调整的堆数组,i是待调整的数组元素的位置,length是数组的长度
	void HeapAdjust(int array[], int i, int nLength) {
		int nChild, nTemp;

		for (nTemp = array[i]; 2 * i + 1 < nLength; i = nChild) {

			// 子结点的位置是 父结点位置 * 2 和父节点位置*2+1 // 修改处
			nChild = 2 * i + 1;

			// 得到子结点中较大的结点
			if (nChild != nLength - 1 && array[nChild + 1] > array[nChild])
				++nChild;

			// 如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点
			if (nTemp < array[nChild]) {
				array[i] = array[nChild];
			} else // 否则退出本次循环
			{
				break;
			}
		}

		// 最后把需要调整的元素值放到合适的位置
		array[i] = nTemp;
	}

	// 堆排序算法
	void HeapSort(int array[], int length) {

		// 调整序列的前半部分元素,调整完之后第一个元素是序列的最大的元素
		for (int i = length / 2 - 1; i >= 0; --i) {
			HeapAdjust(array, i, length);
		}

		// 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素4
		for (int i = length - 1; i > 0; --i) {

			// 把第一个元素和当前的最后一个元素交换,保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
			int tem = array[0];
			array[0] = array[i];
			array[i] = tem;

			// 不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
			HeapAdjust(array, 0, i);
		}
	}

	// =========================堆排序1End==============================

	// =========================堆排序2Begin============================
	void heapAdjust(int a[], int i, int n) {
		int tem;
		int min_p = 2 * i;
		if (2 * i < n) {
			min_p = 2 * i;
		}
		if (2 * i + 1 < n) {
			if (a[2 * i + 1] > a[2 * i]) {
				min_p = 2 * i + 1;
			}
		}
		if (a[min_p] > a[i]) {
			tem = a[min_p];
			a[min_p] = a[i];
			a[i] = tem;
			if (2 * min_p < n)
				heapAdjust(a, min_p, n);
		}

	}

	void Heap_sort(int a[], int n) {
		int i, tem;
		for (i = n / 2 - 1; i >= 0; i--) {
			heapAdjust(a, i, n);
		}
		for (i = 0; i < n - 1; i++) {
			tem = a[0];
			a[0] = a[n - i - 1];
			a[n - i - 1] = tem;
			heapAdjust(a, 0, n - i - 1);
		}
	}

	// ========================堆排序2End========================

	// ========================基数排序Begin=====================
	/**
	 * 基数排序 结合桶式排序,分两种从高位到低位和从低位到高位。案例代码为从低位到高位 第一步:得到数组内最大位数 第二步:进行多次
	 * 桶式排序,次数为排序最大数字的位数 例子:52,38,23,72,271 第一步:数组元素最大位数为3,
	 * 第二步:第一次桶式排序,针对数组元素的个位:排序结果为:271,52,72,23,38,按个位桶式排序就完成了 继续:
	 * 第二次桶式排序,按照数组元素的十位:排序结果为:23,38,52,271,72 继续:
	 * 第三次桶式排序,按照数组元素的百位:排序结果为:23,38,52,72,271 排序完成。
	 * 
	 * @author
	 * 
	 */
	void radixSort(int[] array) {
		int maxW = 0;
		int index = 0;

		// 第一步:得到数组内最大元素的位数
		for (int i = 0; i < array.length; i++) {
			if (maxW < array[i]) {
				maxW = array[i];
			}
		}

		maxW = getNumberLength(maxW);

		// 第二步:进行多次 桶式排序,次数为排序最大数字的位数
		while (index < maxW) {
			int[] tempArray = new int[array.length];
			int[] bucketArray = new int[10];
			System.arraycopy(array, 0, tempArray, 0, array.length);
			for (int i = 0; i < array.length; i++) {
				bucketArray[getNumberIndex(index, array[i])]++;
			}

			for (int i = 1; i < bucketArray.length; i++) {
				bucketArray[i] = bucketArray[i] + bucketArray[i - 1];
			}
			for (int i = array.length - 1; i >= 0; i--) {
				array[--bucketArray[getNumberIndex(index, tempArray[i])]] = tempArray[i];
			}
			index++;
		}
	}

	int getNumberIndex(int index, int number) {
		int num = 0;
		num = (int) (number / Math.pow(10, index)) % 10;
		return num;
	}

	int getNumberLength(int number) {
		int count = 1;
		int index = 1;
		while ((number - Math.pow(10, index)) > 0) {// Math.pow(x,y)计算x的y次幂
			count++;
			index++;
		}
		return count;
	}

	// =======================基数排序End==========================

	// =======================归并排序Begin========================
	//将有二个有序数列a[first...mid]和a[mid...last]合并。 
	void merge(int[] unsorted, int first, int mid, int last, int[] sorted) {
	int i = first, j = mid;
		int k = 0;
		while (i < mid && j < last)
			if (unsorted[i] < unsorted[j]) {
				sorted[k++] = unsorted[i++];
			} else if (unsorted[i] > unsorted[j]) {
				sorted[k++] = unsorted[j++];
			} else {
				sorted[k++] = unsorted[i++];
				sorted[k++] = unsorted[j++];
			}
		while (i < mid)
			sorted[k++] = unsorted[i++];
		while (j < last)
			sorted[k++] = unsorted[j++];

		for (int v = 0; v < k; v++)
			unsorted[first + v] = sorted[v];
	}

	void merge_sort(int[] unsorted, int first, int last, int[] sorted) {
		if (first + 1 < last) {
			int mid = (first + last) / 2;
			merge_sort(unsorted, first, mid, sorted);//左边有序 
			merge_sort(unsorted, mid, last, sorted);//右边有序
			merge(unsorted, first, mid, last, sorted);//再将二个有序数列合并 
		}
	}

	// =========================归并排序End========================

	// =========================希尔排序Begin======================
	void shell_sort(int[] array) {
		int groupLen = 0;
		int len = array.length;
		for (groupLen = len / 2; groupLen > 0; groupLen /= 2) {
			for (int i = 0; i < len - groupLen; i++) {
				for (int j = i; j < len - groupLen; j += groupLen) {
					if (array[j] > array[j + groupLen]) {
						int temp = array[j];
						array[j] = array[j + groupLen];
						array[j + groupLen] = temp;
					}
				}
			}
		}
	}

	// =====================希尔排序End==========================

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Sort sort = new Sort();

		System.out
				.println("*********************选择排序*********************");
		int[] selectArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		sort.select_sort(selectArray);
		print(selectArray);

		System.out
				.println("*********************冒泡排序**********************");
		int[] bubbleArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		sort.bubble_sort(bubbleArray);
		// sort.bubbleSort(bubbleArray);
		print(bubbleArray);

		System.out
				.println("*********************直接插入排序******************");
		int[] x = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		sort.insertion_sort(x);
		print(x);

		System.out
				.println("*********************快速排序**********************");
		int[] quickArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		// sort.quick_sort(x, 0, x.length - 1);
		sort.QuickSort(quickArray, 0, quickArray.length - 1);
		print(quickArray);

		System.out
				.println("*********************堆排序************************");
		int a[] = { 71, 18, 151, 138, 160, 63, 174, 169, 79, 78 };
		sort.HeapSort(a, a.length);
		// sort.Heap_sort(a, a.length);
		print(a);

		System.out
				.println("*********************基数排序***********************");
		int[] array = new int[] { 51, 82, 23, 94, 35, 76, 117, 238, 909, 40, 11 };
		sort.radixSort(array);
		print(array);

		System.out
				.println("*********************归并排序***********************");
		int[] mergeArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		int[] sorted = new int[mergeArray.length];
		sort.merge_sort(mergeArray, 0, mergeArray.length, sorted);
		print(mergeArray);

		System.out
				.println("*********************希尔排序***********************");
		int[] shellArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
		sort.shell_sort(shellArray);
		print(shellArray);
	}

	static void print(int[] a) {
		for (int i = 0; i < a.length; i++) {
			if (i == a.length - 1)
				System.out.println(a[i]);
			else
				System.out.print(a[i] + ",");
		}
		System.out
				.println("**********************end****************************");
	}
}



递归排序的示例图:


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:47945次
    • 积分:830
    • 等级:
    • 排名:千里之外
    • 原创:33篇
    • 转载:22篇
    • 译文:0篇
    • 评论:1条