Java 实现双向冒泡排序

冒泡排序_鸡尾酒排序

就是双向冒泡排序

此算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序,外层比较左右边界l<r,

内层一个循环从左向右比,取高值置后;一个循环从右向左,取低值置前;

效率上,O(N^2), 不比普通的冒泡快

public class Bubble_CocktailSort {
	public static void main(String[] args) {
		int len = 10;
		int[] ary = new int[len];
		Random random = new Random();
		for (int j = 0; j < len; j++) {
			ary[j] = random.nextInt(1000);
		}
		/*
		 * 交换次数最小也是1次,最大也是(n^2-n)/2次
		 */
//		ary=new int[]{10,9,8,7,6,5,4,3,2,1}; //测试交换次数
//		ary=new int[]{1,2,3,4,5,6,7,8,10,9}; //测试交换次数
		System.out.println("-------排序前------");
		for (int j = 0; j < ary.length; j++) {
			System.out.print(ary[j] + " ");
		}

		orderAsc1(ary);
//		orderAsc2(ary);

		//降序,只需要把判断大小于 置换一下

	}

	static void orderAsc1(int[] ary) {
		int compareCount = 0;//比较次数
		int changeCount = 0;//交换次数
		int len = ary.length;
		int left = 0, right = len -1, tl, tr;
		while (left < right) {//外层固定循环次数
			tl = left + 1;
			tr = right - 1;
			for (int k = left; k < right; k++) {//内层从多到少递减比较次数, 从左向右
				if (ary[k] > ary[k + 1]) {//前大于后, 置换
					ary[k] = ary[k + 1] + (ary[k + 1] = ary[k]) * 0;//一步交换
					changeCount++;
					tr = k; //一轮中最后一比较的时候,将k所在索引赋给tr,  tr表示以后比较的结束索引值,  从左向右比后,k表示左边的索引
				}
				compareCount++;
			}
			right = tr;
			for (int k = right; k > left; k--) {//内层从多到少递减比较次数, 从右向左
				if (ary[k] < ary[k - 1]) {//后小于前 置换
					ary[k] = ary[k - 1] + (ary[k - 1] = ary[k]) * 0;//一步交换
					changeCount++;
					tl = k; //一轮中最后一比较的时候,将k所在索引赋给tl,  tl表示以后比较的开始索引值, 从向右向左比后,k表示右边的索引
				}
				compareCount++;
			}
			left = tl;
		}
		System.out.println("\n-----orderAsc1升序排序后------比较次数:" + compareCount + ", 交换次数:" + changeCount);
		for (int j = 0; j < len; j++) {
			System.out.print(ary[j] + " ");
		}
	}

	//跟orderAsc1的思路没有区别
	static void orderAsc2(int[] ary) {
		int compareCount = 0;//比较次数
		int changeCount = 0;//交换次数
		int len = ary.length;
		int l = 0, r = len -1, tl, tr;
		for (; l < r; ) {//外层固定循环次数
			tl = l + 1;
			tr = r - 1;
			/*
			 * 从左向右比,将大的移到后面
			 */
			for (int k = l; k < r; k++) {
				if (ary[k] > ary[k + 1]) {
					int temp = ary[k] + ary[k + 1];
					ary[k + 1] = temp - ary[k + 1];
					ary[k] = temp - ary[k + 1];
					changeCount++;
					tr = k;
				}
				compareCount++;
			}
			r = tr;
			/*
			 * 从右向左比,将小的移到前面
			 */
			for (int k = r; k > l; k--) {
				if (ary[k] < ary[k - 1]) {
					int temp = ary[k] + ary[k - 1];
					ary[k - 1] = temp - ary[k - 1];
					ary[k] = temp - ary[k - 1];
					changeCount++;
					tl = k;
				}
				compareCount++;
			}
			l = tl;
		}
		System.out.println("\n-----orderAsc2升序排序后------比较次数:" + compareCount + ", 交换次数:" + changeCount);
		for (int j = 0; j < len; j++) {
			System.out.print(ary[j] + " ");
		}
	}
}

打印

-------排序前------
783 173 53 955 697 839 201 899 680 677
-----orderAsc1升序排序后------比较次数:34, 交换次数:22
53 173 201 677 680 697 783 839 899 955 
时间: 2024-11-06 06:26:05

Java 实现双向冒泡排序的相关文章

Java版双向冒泡排序算法

冒泡排序算法是一种较为简单的并且稳定的排序算法,该算法的时间复杂度最好为O(n),最差时为O(n^2),需要的空间复杂度为O(1). 这里的算法稳定性是指 经过排序后,各元素仍然能保持它们在排序之前的相对次序,就称该算法是稳定的,反之,则为不稳定的. 例如,一组数排序前是a1,a2,a3,a4,a5,其中a2=a4,经过某种排序后a1,a2,a4,a3,a5,则说明这种排序是稳定的,因为a2排序前后都在a4前面:若排序的结果是a1,a4,a2,a3,a5,则该排序就不是稳定的了.------摘自

双向冒泡排序算法--java

以整数升序排序为例来简单说明一下双向冒泡排序的过程:首先从前往后把最大数移到最后,然后反过来从后往前把最小的一个数移动到数组最前面,这一过程就是第一轮,然后重复这一过程,最终就会把整个数组从小到大排列好.双向冒泡排序要稍微优于传统的冒泡排序,因为双向排序时数组的两头都排序好了,我们只需要处理数组的中间部分即可,而单向即传统的冒泡排序只有尾部的元素是排好序的,这时每轮处理都需要从头一直处理到已经排好序元素的前面一个元素.虽然它在效率上有了点改进,但它也不能大幅度提高其排序的效率,这是由冒泡排序的基

[6] 算法之路 - 双向冒泡排序之Shaker

Shaker排序 –算法 1. 气泡排序的双向进行,先让气泡排序由左向右进行,再来让气泡排序由右往左进行,如此完成一次排序的动作 2. 使用left与right两个旗标来记录左右两端已排序的元素位置. 一个排序的例子如下所示: 排序前:45 19 77 81 13 28 18 1977 11 往右排序:19 45 77 13 28 18 19 7711 [81] 向左排序:[11] 19 45 77 13 28 1819 77 [81] 往右排序:[11] 19 45 13 28 18 19[7

排序算法系列:冒泡排序与双向冒泡排序

概述 排序算法应该算是一个比较热门的话题,在各个技术博客平台上也都有一些博文进行了一定程度的讲解.但还是希望能从自我完善的角度出发,可以更详细.全面.形象地表达这些算法的精髓.本文就先从最简单的冒泡排序开始说起,别说你已经彻底了解了冒泡排序算法(虽然一开始我也是这样以为的). 版权说明 本文链接:http://blog.csdn.net/lemon_tree12138/article/details/50474230 – Coding-Naga - 转载请注明出处 目录 概述 版权说明 目录 冒

YDU 2748: 双向冒泡排序

2748: 双向冒泡排序 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 193  Solved: 100 [Submit][Status][Web Board] Description 注:本题只需要提交填写部分的代码,请按照C++语言方式提交. 双向冒泡从小到大排序算法描述: (1)从当前序列的第1个元素开始,对相邻元素从前往后两两比较,不满足条件(从小到大)则彼此交换,一直到序列结束.此时最后1个元素为最大值. (2)从当前序列的倒数第2个元

双向冒泡排序

<center><h2>问题 G: 双向冒泡排序</h2></center><h2>题目描述</h2><div class="content"><h1 style="margin: 0px; font-size: 30px; line-height: 36px; font-family: 'Times New Roman'; color: rgb(51, 51, 51); text-re

Java实现双向循环链表的基本操作

1 package Eric.ADT; 2 3 /** 4 * <p> 5 * Title:doubleLinkedList 6 * </p> 7 * <p> 8 * Description:用java实现双向循环链表的基本操作 9 * </p> 10 * <p> 11 * Location:Frostburg 12 * </p> 13 * 14 * @author: Eric.Chen 15 * @date:2017年9月23日下午

比较快速排序,冒泡排序,双向冒泡排序的执行快慢

快速排序 原理是找出一个元素(理论上可以随便找一个)作为基准(pivot),然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值,如此作为基准的元素调整到排序后的正确位置.递归快速排序,将其他n-1个元素也调整到排序后的正确位置.最后每个元素都是在排序后的正 确位置,排序完成.所以快速排序算法的核心算法是分区操作,即如何调整基准的位置以及调整返回基准的最终位置以便分治递归. 冒泡排序算法 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,

Problem D: 双向冒泡排序

Problem D: 双向冒泡排序 Time Limit: 1 Sec  Memory Limit: 128 MBSubmit: 447  Solved: 197[Submit][Status][Web Board] Description 注:本题只需要提交填写部分的代码 双向冒泡从小到大排序算法描述: (1)从当前序列的第1个元素开始,对相邻元素从前往后两两比较,不满足条件(从小到大)则彼此交换,一直到序列结束.此时最后1个元素为最大值. (2)从当前序列的倒数第2个元素开始,对相邻元素从后