算法效率对比
基于java对常见排序算法时间效率进行验证，
常用排序算法理论时间复杂度如下：
验证源码如下：
package four;
import java.util.Calendar;
public class Four {
public static void main(String[] args) {
// TODO Auto-generated method stub
int len = 10000;
int arr[]=new int[len];
for(int i=0;i<len-1;i++)
{
//生成0-10000随机数
int temp = (int)(Math.random()*10000);
arr[i] = temp;
}
int temp1,temp2;
//创建冒泡对象
Bubble bubble = new Bubble();
int arr1[]=new int[len];
for(int i=0;i<len;i++) {
arr1[i]=arr[i];
}
//计算冒泡排序系统时间
Calendar t1 = Calendar.getInstance();
temp1=(int)(t1.getTimeInMillis());
bubble.sort(arr1);
Calendar t2 = Calendar.getInstance();
temp2=(int)(t2.getTimeInMillis());
System.out.println("冒泡排序时间：" + (temp2-temp1));
//创建选择排序对象
Select select= new Select();
int arr2[]=new int[len];
for(int i=0;i<len;i++) {
arr2[i]=arr[i];
}
//计算选择排序系统时间
Calendar t3 = Calendar.getInstance();
temp1=(int)(t3.getTimeInMillis());
select.sort(arr2);
Calendar t4 = Calendar.getInstance();
temp2=(int)(t4.getTimeInMillis());
System.out.println("\n选择排序时间：" + (temp2-temp1));
//创建插入排序对象
Insert insert = new Insert();
int arr3[]=new int[len];
for(int i=0;i<len;i++) {
arr3[i]=arr[i];
}
//计算插入排序系统时间
Calendar t5 = Calendar.getInstance();
temp1=(int)(t5.getTimeInMillis());
insert.sort(arr3);
Calendar t6 = Calendar.getInstance();
temp2=(int)(t6.getTimeInMillis());
System.out.println("\n插入排序时间：" + (temp2-temp1));
//创建快速排序对象
Quicksort quicksort = new Quicksort();
int arr4[]=new int[len];
for(int i=0;i<len;i++) {
arr4[i]=arr[i];
}
//计算插入排序系统时间
Calendar t7 = Calendar.getInstance();
temp1=(int)(t7.getTimeInMillis());
quicksort.sort(0,len-1,arr4);
Calendar t8 = Calendar.getInstance();
temp2=(int)(t8.getTimeInMillis());
System.out.println("\n快速排序时间：" + (temp2-temp1));
System.out.println("排序数组：");
print_array(arr4);
System.out.println("\n>>>>>>>>\n");
System.out.println("原数组：");
print_array(arr);
}
public static void print_array(int array[]) {
for(int i=0;i<array.length-1;i++)
{
System.out.print(array[i]+"\t");
}
}
}
class Bubble
{
//排序方法
public void sort(int array[]) {
int temp;
//外层循环，决定一共循环的次数
for(int i=0;i<array.length-1;i++)
{
//内层循环，开始逐个比较，如果发现前一个数比后一个数大则交换
for(int j=0;j<array.length-1-i;j++)
{
if(array[j]>array[j+1])
{
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
}
}
class Select{
//选择排序方法
public void sort(int array[]) {
int temp=0;
for (int i=0;i<array.length-1;i++)
{
//假定第一个数最小
int min=array[i];
//记录下标索引
int min_index=i;
for (int j=i+1;j<array.length;j++)
{
if (min>array[j])
{
min=array[j];
min_index=j;
}
}
//一次循环找到本次最小值
temp=array[i];
array[i]=array[min_index];
array[min_index]=temp;
}
}
}
class Insert{
//插入排序方法
public void sort(int array[]) {
for(int i=1;i<array.length;i++)
{
int insert_value=array[i];
//insert value准备和前一个数比较
int index=i-1;
while(index>=0&&insert_value<array[index])
{
//将把array[index]向后移动一位
array[index+1]=array[index];
//让index向前移动一位
index--;
}
//将insert value插入到适当位置
array[index+1]=insert_value;
}
}
}
class Quicksort{
//快速排序方法
public void sort(int left,int right,int array[]) {
int R=right;
int L=left;
int temp;
int pivot=array[(left+right)/2];
while(left<right)
{
while(array[left]<pivot)
left++;
while(array[right]>pivot)
right--;
if (left>=right)
break;
temp=array[left];
array[left]=array[right];
array[right]=temp;
if(array[left]==pivot)
--right;
if(array[right]==pivot)
++left;
}
if(left==right)
{
left++;
right--;
}
if(L<right)
sort(L,right,array);
if(R>left)
sort(left,R,array);
}
}
结论:基础排序算法单纯时间上来说，对10000个数的排序效率：
quick_sort>select_sort>insert_sort>bubble_sort
理论联系实际，实验结果与理论基本吻合。
基础排序算法实现详情
- 冒泡排序
冒泡排序算法的原理如下：
step1：比较相邻的元素。如果第一个比第二个大，就交换他们两个。
step2：对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
step3：针对所有的元素重复以上的步骤，除了最后一个。
step4：持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
冒泡排序是最稳定排序之一。
代码实现如下：
package Bubble;
import java.util.Calendar;
public class Bubble {
public static void main(String[] args) {
// TODO Auto-generated method stub
int len = 1000;
int temp1,temp2;
//创建选择对象
Bubble1 bubble = new Bubble1(len);
//计算排序系统时间
Calendar t1 = Calendar.getInstance();
System.out.println("选择排序开始时间：" + t1.getTime());
temp1=(int)(t1.getTimeInMillis());
bubble.sort(bubble.arr);
Calendar t2 = Calendar.getInstance();
System.out.println("选择排序结束时间：" + t2.getTime());
temp2=(int)(t2.getTimeInMillis());
System.out.println((temp2-temp1));
bubble.print_array(1000);
}
}
class Bubble1{
public int arr[];
public Bubble1(int len) {
this.arr = new int[len];
for(int i=0;i<len-1;i++)
{
//生成0-10000随机数
int temp = (int)(Math.random()*10000);
arr[i] = temp;
}
}
private void swap(int a,int b)
{
int temp;
temp=a;
a=b;
b=temp;
}
//排序方法
public void sort(int array[]) {
//外层循环，决定一共循环的次数
for(int i=0;i<array.length-1;i++)
{
//内层循环，开始逐个比较，如果发现前一个数比后一个数大则交换
for(int j=0;j<array.length-1-i;j++)
{
if(array[j]>array[j+1])
{
swap(array[j],array[j+1]);
}
}
}
}
public void print_array(int len) {
for(int i=0;i<len-1;i++)
{
System.out.print(this.arr[i]+"\t");
}
}
}
结果演示
-
选择排序
选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。、
实现代码：
import java.util.Calendar;
public class Select {public static void main(String[] args) { // TODO Auto-generated method stub int len = 1000; int temp1,temp2; //创建选择对象 Select1 select = new Select1(len); //计算排序系统时间 Calendar t1 = Calendar.getInstance(); System.out.println("选择排序开始时间：" + t1.getTime()); temp1=(int)(t1.getTimeInMillis()); select.sort(select.arr); Calendar t2 = Calendar.getInstance(); System.out.println("选择排序结束时间：" + t2.getTime()); temp2=(int)(t2.getTimeInMillis()); System.out.println((temp2-temp1)); select.print_array(1000);}
}
class Select1{
public int arr[];
public Select1(int len) {
this.arr = new int[len];
for(int i=0;i<len-1;i++)
{
//生成0-10000随机数
int temp = (int)(Math.random()*10000);
arr[i] = temp;
}
}
//选择排序方法
public void sort(int array[]) {
int temp=0;
for (int i=0;i<array.length-1;i++)
{
//假定第一个数最小
int min=array[i];
//记录下标索引
int min_index=i;
for (int j=i+1;j<array.length;j++)
{
if (min>array[j])
{
min=array[j];
min_index=j;
}
}
//一次循环找到本次最小值
temp=array[i];
array[i]=array[min_index];
array[min_index]=temp;
}
}
public void print_array(int len) {
for(int i=0;i<len-1;i++)
{
System.out.print(this.arr[i]+"\t");
}
}
}
- 插入排序
插入排序算法原理：从整个待排序列中选出一个元素插入到已经有序的子序列中去，得到一个有序的、元素加一的子序列，直到整个序列的待插入元素为0，则整个序列全部有序。
实现代码：
import java.util.Calendar;
public class Insert {
public static void main(String[] args) {
// TODO Auto-generated method stub
int len = 1000;
int temp1,temp2;
//创建插入排序对象
Insert1 insert = new Insert1(len);
//计算排序系统时间
Calendar t1 = Calendar.getInstance();
System.out.println("插入排序开始时间：" + t1.getTime());
temp1=(int)(t1.getTimeInMillis());
insert.sort(insert.arr);
Calendar t2 = Calendar.getInstance();
System.out.println("插入排序结束时间：" + t2.getTime());
temp2=(int)(t2.getTimeInMillis());
System.out.println((temp2-temp1));
insert.print_array(1000);
}
}
class Insert1{
public int arr[];
public Insert1(int len) {
this.arr = new int[len];
for(int i=0;i<len-1;i++)
{
//生成0-10000随机数
int temp = (int)(Math.random()*10000);
arr[i] = temp;
}
}
//插入排序方法
public void sort(int array[]) {
for(int i=1;i<arr.length;i++)
{
int insert_value=arr[i];
//insert value准备和前一个数比较
int index=i-1;
while(index>=0&&insert_value<arr[index])
{
//将把arr[index]向后移动一位
arr[index+1]=arr[index];
//让index向前移动一位
index--;
}
//将insert value插入到适当位置
arr[index+1]=insert_value;
}
}
//打印数组方法
public void print_array(int len) {
for(int i=0;i<len-1;i++)
{
System.out.print(this.arr[i]+"\t");
}
}
}
- 快速排序
快速基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
具体代码：
import java.util.Calendar;
public class Quicksort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int len = 1000;
int temp1,temp2;
//创建快速排序对象
Quicksort1 quicksort = new Quicksort1(len);
//计算排序系统时间
Calendar t1 = Calendar.getInstance();
System.out.println("快速排序开始时间：" + t1.getTime());
temp1=(int)(t1.getTimeInMillis());
quicksort.sort(0,len-1,quicksort.arr);
Calendar t2 = Calendar.getInstance();
System.out.println("快速排序结束时间：" + t2.getTime());
temp2=(int)(t2.getTimeInMillis());
System.out.println((temp2-temp1));
quicksort.print_array(1000);
}
}
class Quicksort1{
public int arr[];
public Quicksort1(int len) {
this.arr = new int[len];
for(int i=0;i<len-1;i++)
{
//生成0-10000随机数
int temp = (int)(Math.random()*10000);
arr[i] = temp;
}
}
public void swap(int a,int b) {
int temp;
temp=a;
a=b;
b=temp;
}
//快速排序方法
public void sort(int left,int right,int array[]) {
int R=right;
int L=left;
int temp;
int pivot=array[(left+right)/2];
while(left<right)
{
while(array[left]<pivot)
left++;
while(array[right]>pivot)
right--;
if (left>=right)
break;
temp=array[left];
array[left]=array[right];
array[right]=temp;
if(array[left]==pivot)
--right;
if(array[right]==pivot)
++left;
}
if(left==right)
{
left++;
right--;
}
if(L<right)
sort(L,right,array);
if(R>left)
sort(left,R,array);
}
//打印数组方法
public void print_array(int len) {
for(int i=0;i<len-1;i++)
{
System.out.print(this.arr[i]+"\t");
}
}
}
扫一扫
1607
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
