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("查无此处");
//}
}
/*********************二分法查找*****************/
}
分享到：
相关推荐
数据结构 课程设计 多种排序算法 有界面 数据结构 课程设计 多种排序算法 有界面 数据结构 课程设计 多种排序算法 有界面 数据结构 课程设计 多种排序算法 有界面 数据结构 课程设计 多种排序算法 有界面
数据结构作业六,各种排序算法性能比较。
设计一个负责排序的程序包，实现多种排序算法，至少包括插入排序、冒泡排序和快速排序算法。 要求： 1.可以对任何简单类型和任意对象进行排序 2.可以支持升序、降序、字典排序等多种顺序要求 3.可以随意增加排序算法...
六种排序算法的c语言实现，可选择排序数据量大小，文件在D盘生成
提供多种排序算法的模块.文件读入.文件输出.友好用户界面.带有排序时间测定功能.
1.可以对任何简单类型和任意对象进行排序 ...3.可以随意增加排序算法和顺序要求，保证其他程序不修改 4.减少程序代码中逻辑上的冗余 5.至少用两种方案编程实现该程序包，并说明两个方案的优缺点 包括实验报告。
包含以下九种排序算法的C代码实现源码：可以自已生成随机数以便测试： 选择(SelectSort)、插入(InsertSort)、冒泡(BubbleSort)、Shell排序(ShellSort)、快速排序(QuickSort)、快速排序的改进算法(QStackSort)、合并...
实验内容及要求： 输入n个整数，分别用希尔排序、快速排序、堆排序和归并排序实现由小到大排序并输出排序结果。要求n=10，15，20进行三组排序实验。...实验目的：掌握希尔排序、快速排序、堆排序、归并排序算法。
快速排序，基数排序，插入排序，希尔排序，堆排序，归并排序等算法对数排序的时间进行比较。可以对5000000以内（超大数据量）的随机数（可能存在超大数值）进行排序！！！
代码包括多种排序算法，折半插入、冒泡排序、快速排序、简单选择排序、堆排序、归并排序等
设计一个负责排序的程序包，实现多种排序算法，至少包括插入排序、冒泡排序和快速排序算法。 要求： 1.可以对任何简单类型和任意对象进行排序 2.可以支持升序、降序、字典排序等多种顺序要求 3.可以随意增加排序算法...
多种排序算法的介绍和PPT演示,如 插入排序 快速排序 选择排序 归并排序 基数排序 等
多种排序算法的程序实现.doc
数据库实验 包含九个实验 有多种排序算法 链表的插入删除翻转等 树的三种遍历算法 字符串算法 移位密码 代换密码等
几种内部排序算法在进行时间复杂度分析的时候给出了算法执行的大概执行时间。通过几组有代表意义的随机数据的比较，算出几种这几种排序算法的关键字比较次数和关键字移动次数，以便我们分析算法效率。 1、通过修改...
在实际应用中，插入排序和现则排序因为实现简单，使用的比较多，但是在对效率要求比较高、且待排序数据量大的场合，还是应该采用时间复杂度较低的排序算法，因此对排序算法进行试验比较，增强实践认识很有必要。...
源程序给出了插入排序、选择排序、希尔排序、堆排序、冒泡、双向冒泡、快速排序、归并排序、递归的归并排序、基数排序等多种排序算法，其中有17处需要填空。
1.直接插入排序--增量法 2.希尔排序 3.交换排序 4.快速排序 5.直接选择排序 6.堆排序 7.归并排序
内含有快排、冒泡、插入排序、merge等多种排序法的实现，并附有测试例子，适合算法学习者