多种排序算法

package a1;

import java.util.Arrays;

public class ComparatorTest
{
	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
	   Book b1=new Book(8,"java");
	   Book b2=new Book(3,"C语言");
	   Friut f1=new Friut(6,"apple");
	   Object [] oo={b1,b2,f1};
	   Arrays.sort(oo, new MyComparator());
	   System.out.println(Arrays.toString(oo));
	}

}

 package a1;

import java.util.Comparator;

public class Book implements Comparable
{
 private int id;
private String name;
public int getId()
{
	return id;
}
@Override
public String toString()
{
		// TODO Auto-generated method stub
		return "编号:"+id+"名字:"+name;
}
public void setId(int id)
{
	this.id = id;
}
public Book(int id, String name)
{
	super();
	this.id = id;
	this.name = name;
}
public String getName()
{
	return name;
}
public void setName(String name)
{
	this.name = name;
}
@Override
public int compareTo(Object o)
{
	// TODO Auto-generated method stub
	Book b=(Book)o;
	Integer id=this.id;
	int result=id.compareTo(b.id);
	if(result==0)
	{
		result=this.name.compareTo(b.name);
	}
	return result;
}


	

}

 

package a1;

import java.lang.reflect.Method;
import java.util.Comparator;

/**
 * 
 * @author zyf
 *@see 通用比较器 要求:必须有相同的字段
 */
public class MyComparator implements Comparator
{
   
	@Override

	public int compare(Object o1, Object o2)
	{
		//获取类的自描述对象
        Class c1=o1.getClass();
        Class c2=o2.getClass();
        //Field f1,f2;
        Method m1,m2;
        Integer id1=null,id2=null;
        try
		{
        //获取字段的自描述对象
		 //f1=c1.getDeclaredField("id");
		 //f2=c2.getDeclaredField("id");
		 //id1=f1.getInt(o1);
		 //id2=f2.getInt(o2);
		 //返回get方法的描述对象
		 m1=c1.getDeclaredMethod("getId");
		 m2=c2.getDeclaredMethod("getId");
		 id1=(Integer) m1.invoke(o1);
		 id2=(Integer) m2.invoke(o2);
		 //从对象中得到字段值
		 
		} catch (Exception e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
		
		return id1.compareTo(id2);
	}

	
   

}

 

package a1;
/**算法是一种解决特定问题的一种解决方案
import java.util.Arrays;
class SStudent
{
	private int num;
	String name;
	public int getNum() 
	{
		return num;
	}
	
	public String toString() 
	{
		// TODO Auto-generated method stub
		return "学号:"+num+"姓名:"+name;
	}
	public SStudent(int num, String name) 
	{
		super();
		this.num = num;
		this.name = name;
	}
	public void setNum(int num) 
	{
		this.num = num;
	}
	public String getName() 
	{
		return name;
	}
	public void setName(String name) 
	{
		this.name = name;
	}
	
}

public class ObjectSort 
{
	//定义一个对象数组
	static int []a ={8,9,5,11,7,13,6};
	static Book[] books={new Book(9,"java"),new Book(5,"C语言"),new Book(13,"Linux"),new Book(6,"Oracle"),new Book(8,"JavaEE")};
    static MyComparator com;
	public static void setCom(MyComparator com)
	{
	   ObjectSort.com=com;
	}
	//交换
	public static void swap(int i,int j)
	{
	 int temp=a[i];
	 a[i]=a[j];
	 a[j]=temp;
	}
	//对象的交换
	public static void obj_swap(int i,int j)
	{
		Book temp=books[i];
		books[i]=books[j];
		books[j]=temp;
	}
	/**
	 * 对象数组的冒泡排序
	 */
	public static void obj_compare()
	{
		for(int i=0;i<books.length;i++)
		{
			for(int j=books.length-1;j>i;j--)
			{
				if(com.compare(books[i],books[j])>0)
				{
					obj_swap(i,j);
				}
			}
		}
		 System.out.println("对象冒泡排序的结果为:"); 
		  System.out.print(Arrays.toString(books));
	}
	/**
	 * 冒泡排序
	 */
	public static void fun()
	{
	      for(int i=0;i<books.length-1;i++)
	      {
	    	  for(int j=i+1;j<books.length;j++)
	    	  {
	    		  if(books[i].compareTo(books[j])>0)
	    		  {
	    		    obj_swap(i,j);
	    		  }
	    	  }
	      }
	  System.out.println("冒泡排序的结果为:"); 
	  System.out.print(Arrays.toString(books));
	}
	/**
	 * 对象数组的选择排序
	 */
	public static void obj_select()
	{
		for(int i=0;i<books.length;i++)
		{
			int min=i;
			for(int j=i+1;j<books.length;j++)
			{
				if(books[min].compareTo(books[j])>0)
				{
					min=j;
				}
			}
			if(min!=i)
			{
				obj_swap(i,min);
			}
		}
		System.out.println("对象数组的选择排序的结果为:"); 
		System.out.print(Arrays.toString(books));
	}
	/**
	 * 对象数组的选择排序
	 */
	public static void select()
	{
		for(int i=0;i<a.length;i++)
		{
			int min=i;
			for(int j=i+1;j<a.length;j++)
			{
				if(a[min]>a[j])
				{
					min=j;
				}
			}
			if(min!=i)
			{
				swap(i,min);
			}
		}
		System.out.println("\n选择排序的结果为:"); 
		System.out.print(Arrays.toString(a));
	}
	/**
	 * 插入排序
	 */
	public static void insert()
	{
		for(int i=1;i<a.length;i++)
		{
			int temp=a[i];
			int in=i;//记录位置
			while(in>0&&a[in-1]>temp)//前面的数字比后面的数字大，比且位置小标>0的时候，需要换位置
			{
				a[in]=a[in-1];//换位置的具体步骤
				in--;//位置小标自减
			}
			a[in]=temp;
		}
	}
	/**
	 * 快速排序
	 * 为部分序列划分排序
	 */
	public static void quick(int begin ,int end)
	{
		if(begin<end)
		{
				int spos=begin;//开始位置
				int epos=end;//结束位置
				int temp=a[spos];//开始位置上的数
				//交换标志
				boolean turn=false;
				while(spos<epos)//开始位置小于结束位置
				{
					if(!turn)
					{
						//从前往后比较
						if(temp>a[epos])
						{
							swap(spos,epos);
							turn=true;
							spos++;
						}
						else
						{
							epos--;
						}
						
					}
					else
					{
					   //从后往前比较
						if(a[spos]>temp)
						{
							swap(spos,epos);
							turn=false;
							epos--;
						}
						else
						{
							spos++;
						}
						
					}
					//排前半部分
					quick(begin,spos-1);
					//排后半部分
					quick(spos+1,end);
				}
				
		}
	}
	/**
	 * 二分查找(折半查找)
	 * @return 
	 * 
	 */
	public static int binarySearch(int key)
	{
		int s=0;//起始位置
		int e=a.length-1;//末尾位置
		int middle=(s+e)/2;//中间位置
		while(s<=e)//如果前面的位置始终小于等于后面的位置
		{
			//判断待查的数字与中间的位置上的数字是否相等
			if(key==a[middle])//相等
			{
				return middle;
			}
			if(key<a[middle])//小于中间的位置
			{
				e=middle-1;//末尾位置换成中间的位置-1
			}
			if(key>a[middle])//大于中间的位置
			{
				s=middle+1;//起始位置换成中间的位置+1
			}
			middle=(s+e)/2;//循环折半
		}
		return -1;//查不到的情况
	}
	
	public static void main(String[] args) 
	{
		//调用对象数组的冒泡排序
		//fun();
		//调用对象数组的选择排序
		//select();
		/************插入排序********************/
		 //insert();
		/***********插入排序*********************/
		/***********快速排序*********************/
		  //quick(0,a.length-1);
		 //System.out.println(Arrays.toString(a));
		/***********快速排序*********************/
		/*****************对象的冒泡排序*********/
	    //MyComparator mcom=new MyComparator();
	    //setCom(mcom);
        //obj_compare();
		/*****************对象的冒泡排序*********/
		/****************对象数组的选择排序**********/
		
		obj_select();
		/****************对象数组的选择排序**********/
   
    

		 /****************二分法查找**********************/
		 //int index=binarySearch(73);
		 //if(index!=-1)
		 //{
		//	 System.out.println("7在位置"+index);
		 
		 //}
		 //else
		// {
		 // System.out.println("查无此处");
		 //}
	}
	/*********************二分法查找*****************/
}