Sort test BubbleSort innertest

最新推荐文章于 2020-07-16 17:48:26 发布

原创最新推荐文章于 2020-07-16 17:48:26 发布 · 207 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法

笔记专栏收录该内容

11 篇文章

订阅专栏

本文介绍了一个排序算法测试框架，该框架用于评估冒泡排序、插入排序和选择排序等算法的性能。通过生成随机数组并记录排序过程的时间消耗，对比不同算法的效率。

排序算法
冒泡排序

package com.briup.chap09.exercise;

public class SortTest {
	//测试排序算法的时间
	public void testSort(int[] iarray) {
		long startTime = System.currentTimeMillis();
		//new BubbleSort().bubbleSort(iarray);
		//new InsertionSort().insertionSort(iarray);
		//new SelectSort().selectSort(iarray);
		long endTime = System.currentTimeMillis();
		System.out.println("time:"+(endTime-startTime));
	}
	public static void main(String[] args) {
		SortTest st = new SortTest();
		int[] iarray = st.generateArray(100000);
		st.testSort(iarray);
	}
	//随机生成数组
	public int[] generateArray(int n) {
		int[] iarray = new int[n];
		for(int i=0,current=0;i<n;i++) {
			iarray[i] = current;
			current+=(int)(Math.random()*10);
		}
		return iarray;
	}
}
class InsertionSort {
	public void insertionSort(int[] arr) {
		for(int i=0;i<arr.length;i++){
			//无序需要插入的值
			int insertVal = arr[i];
			//有序列表的最后一个位置
			int insertIndex = i-1;
			//有序列表有值，无序比有序的数小
			while(insertIndex>=0 && insertVal<arr[insertIndex]){
				//比过的有序列表向后移一位
				arr[insertIndex+1] = arr[insertIndex];
				//和有序列表的下一个继续比较
				insertIndex--;
			}
			//比较结束，插入的值位于当前后一位
			arr[insertIndex+1] = insertVal;
		}
	}
}
//冒泡排序
class BubbleSort {
	public void bubbleSort(int[] arr) {
		int tmp=0;
		for(int i=0;i<arr.length-1;i++){
      		for(int j=0;j<arr.length-1-i;j++){
      			if(arr[j]>arr[j+1]){
      				tmp=arr[j];
      				arr[j]=arr[j+1];
      				arr[j+1]=tmp;
      			}      		
      		}
		}
	}
}
class SelectSort {
	public void selectSort(int[] arr) {
		int len = arr.length;
		for(int i=0;i<len;i++) {
			//记录当前位置
			int position = i;
			//找出最小的数，并用position指向的最小的位置
			for(int j=i+1;j<len;j++) {
				if(arr[position]>arr[j]) {
					position = j;
				}
			}
			//交换最小数arr[position]和第i位数的位置
			int temp = arr[i];
			arr[i] = arr[position];
			arr[position] = temp;
		}
	}
}

InnerTest

package com.briup.chap09.exercise;

public class InnerTest {
	public static void main(String[] args) {
		int[] iarray = new int[]{10,20,30,14,21,40,1};
		Example example = new Example();
		InnerSort sort = example.getSort();
		iarray = sort.sort(iarray);
		for(int i=0;i<iarray.length;i++) {
			System.out.print(iarray[i]+"\t");
		}
	}
}

Example


package com.briup.chap09.exercise;

public class Example {
	public InnerSort getSort(){
		return new SelectSort();
	}
	public class SelectSort implements InnerSort {
		@Override
		public int[] sort(int[] arr) {
			for(int i=0;i<arr.length;i++){
				//无序需要插入的值
				int insertVal = arr[i];
				//有序列表的最后一个位置
				int insertIndex = i-1;
				//有序列表有值，无序比有序的数小
				while(insertIndex>=0 && insertVal<arr[insertIndex]){
					//比过的有序列表向后移一位
					arr[insertIndex+1] = arr[insertIndex];
					//和有序列表的下一个继续比较
					insertIndex--;
				}
				//比较结束，插入的值位于当前后一位
				arr[insertIndex+1] = insertVal;
			}
			return arr;
		}
	}
}
interface InnerSort {
	public int[] sort(int[] iarray);
}