list.java

（1）写一个final参数类M

import java.util.Date ;
final class M
{
    int compare_count=0;//比较次数
    int exchange_count=0;//交换次数
    int probe_count=0;//探测次数
    long runtime;//所用时间
    //toString方法
    public String toString()
    {
    	String s = "比较次数："+compare_count+"  交换次数："+exchange_count+"  探测次数："+probe_count+"  执行时间："+runtime+"ms";
    	return s;
    }
    //返回比较次数
    public int getCompare_count() {
    	return compare_count;
    }
    //返回交换次数
    public int getExchange_count() {
    	return exchange_count;
    }
    //返回探测次数
    public int getProbe_count() {
    	return probe_count;
    }
    //设置比较次数
    public void setCompare_count(int t) {
    	compare_count = t;
    }
    //设置交换次数
    public void setExchange_count(int t) {
    	exchange_count = t;
    }
    //设置探测次数
    public void setProbe_count(int t) {
    	probe_count = t;
    }
    //设置运行时间
    public void set_time(long t) {
        runtime = t;
    }
}

abstract class A
{
    private int number[];//声明数组变量number
    M mm=new M();//声明变量mm，并初始化
    
    public A(int P[]) {
		this.number=new int[P.length];
		for(int i=0;i<P.length;++i)
			this.number[i]=P[i];
    }
    //比较方法，同时计算比较次数
    final boolean compare(int i, int j)
	{        
    	        int tmp = mm.getCompare_count();
    	        mm.setCompare_count(tmp+1);
		if (number[i] < number[j])
		{
			return true;
		}    
		else
			return false;  	 
	}
 
    //交换方法，同时计算交换次数
    final void exchange(int i, int j) 
	{
		int t;         
		t = number[i];         
		number[i] = number[j];         
		number[j] = t;   
    	        int tmp = mm.getExchange_count();
    	        mm.setExchange_count(tmp+1);
	}

    //探测方法，同时计算探测次数
    final void probe() {
    	for(int i=0;i<number.length-1;i++) {
    		if (number[i] < number[i+1]) 
                {
    	            int tmp = mm.getProbe_count();
    	            mm.setProbe_count(tmp+1);
                    //continue;
                }
		else
                {
		    break;  
                }
    	}
    }
    //抽象方法doSort
    public abstract void doSort(int number[]);
    //抽象方法getType
    public abstract String getType();
    //方法sort，调用doSort，计算执行时间
    final void sort()
	{
        long time1,time2,time3;
        time1 = System.currentTimeMillis();
        for (int i=0;i<100;i++)
        {doSort(number);   }
	time2 = System.currentTimeMillis();
	time3   =   (time2   -   time1); 
        mm.set_time(time3);
	}
    //方法，显示输出信息
    final void show()
	{
		String str="";
		for(int i=0;i<number.length;i++)
			str+=number[i]+" ";
		System.out.println(str);
                System.out.println(mm.toString());
	}
}

//派生类A1，使用冒泡排序
class A1 extends A{
    private String type = "冒泡排序";//声明排序类型
    //继承，调用number
    public A1(int number[]) {
    	super(number);
    }
    
    //  冒泡排序算法
    public void doSort(int number[])
    {
        int n = number.length;
    	for(int i=n;i>0;i--) {
    		for(int j=0;j<i-1;j++) {
    			if (!compare(j,j+1)){
    				exchange(j,j+1);
    			}
    		}
    		probe();
    	}    
    }
    public String getType() {
    	return type;
    }
}

//派生类A2，使用选择排序
class A2 extends A
{
    private String type = "选择排序";

    public A2(int number[]) {
    	super(number);
    }
    //  选择排序算法
    public void doSort(int number[])
	{
		int k;
                int n = number.length;
		for(int i=0;i<n-1;i++)
		{
			k = i;
			for(int j=i+1;j<n;j++)
			{
				if(compare(j,k))
				{
					k = j;
				}
			}
			if(k!=i)
			{
				exchange(k,i);
			}
			probe();
		}
	}
    public String getType() {
    	return type;
    }
}

//派生类A3，使用插入排序
class A3 extends A
{
    private String type = "插入排序";

    public A3(int number[]) {
    	super(number);
    }
    
    //  插入排序算法
	public void doSort(int number[])
	{
                int n = number.length;
		int x,j;
		for(int i=1;i<n;i++)
		{
			x = number[i];
			j = i-1;
			while(j>=0 && compare(i,j))
			{
				exchange(i,j);
				j = j-1;
			}
			number[j+1] = x;
			probe();
		}
	}
    public String getType() {
    	return type;
    }
}


//主类
public class list
{
    public static void main(String[] args) 
	{

		if(args.length<3)  //如果键盘输入的不是一个数，则提示用户输入一个数
                {
                        System.out.println("请输入需要排序的整数以及排序的方法."); 
                        System.out.println("其中第一个数字为排序方法：1-冒泡排序 2-选择排序 3-插入排序");
                        System.out.println("其中第二个数字开始为需要排序的整数。");
                        System.out.println("请输入至少3个数字"); 
                }
                else
		{
                        int c = Integer.parseInt(args[0]);//获得第一个数
			int nums[] = new int[args.length-1]; //要排序的数组
			for(int i=0; i<args.length-1; i++) 
			{
                            nums[i] = Integer.parseInt(args[i+1]); 
			}
			switch(c) //switch结构，分别用于响应不同输入的数
			{
				case 1:
					System.out.println("冒泡排序后的结果：");
					A1 a1=new A1(nums);//排序算法1，冒泡排序
					a1.sort();  //排序
					a1.show(); //输出相关参数
					break;
				case 2:
					System.out.println("选择排序后的结果：");
					A2 a2=new A2(nums);//排序算法2，选择排序
					a2.sort();  //排序
					a2.show(); //输出相关参数
					break;
				case 3:
					System.out.println("插入排序后的结果：");
					A3 a3=new A3(nums);//排序算法3，插入排序
					a3.sort();  //排序
					a3.show(); //输出相关参数
					break;
				default :
					System.out.println("请输入正确排序的方法: 1-冒泡排序 2-选择排序 3-插入排序");
					break;
			}
		}
	}
}