对象数组的排序算法

部分排序

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 SStudent s[]={new SStudent(9,"java"),new SStudent(5,"C语言"),new SStudent(13,"Linux"),new SStudent(6,"Oracle"),new SStudent(8,"JavaEE")};

	/**
	 * 对象数组的冒泡排序
	 */
	public static void fun()
	{
	      for(int i=0;i<s.length-1;i++)
	      {
	    	  for(int j=i+1;j<s.length;j++)
	    	  {
	    		  if(s[i].getNum()>s[j].getNum())
	    		  {
	    		    int temp=s[i].getNum();
	    		    s[i].setNum(s[j].getNum());
	    		    s[j].setNum(temp);
	    		  }
	    	  }
	      }
	  System.out.println("冒泡排序的结果为:"); 
	  System.out.print(Arrays.toString(s));
	}
	/**
	 * 对象数组的选择排序
	 */
	public static void select()
	{
		for(int i=0;i<s.length;i++)
		{
			int min=i;
			for(int j=i+1;j<s.length;j++)
			{
				if(s[min].getNum()>s[j].getNum())
				{
					min=j;
				}
			}
			if(min!=i)
			{
				int temp=s[i].getNum();
				s[i].setNum(s[min].getNum());
				s[min].setNum(temp);
			}
		}
		System.out.println("\n选择排序的结果为:"); 
		System.out.print(Arrays.toString(s));
	}
	public static void main(String[] args) 
	{
		//调用对象数组的冒泡排序
		fun();
		//调用对象数组的选择排序
		select();
	      
	}

}

 对象数组的整体排序

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 SStudent s[]={new SStudent(9,"java"),new SStudent(5,"C语言"),new SStudent(13,"Linux"),new SStudent(6,"Oracle"),new SStudent(8,"JavaEE")};

	/**
	 * 对象数组的冒泡排序
	 */
	public static void fun()
	{
	      for(int i=0;i<s.length-1;i++)
	      {
	    	  for(int j=i+1;j<s.length;j++)
	    	  {
	    		  if(s[i].getNum()>s[j].getNum())
	    		  {
	    		    SStudent temp=s[i];
	    		    s[i]=s[j];
	    		    s[j]=temp;
	    		  }
	    	  }
	      }
	  System.out.println("冒泡排序的结果为:"); 
	  System.out.print(Arrays.toString(s));
	}
	/**
	 * 对象数组的选择排序
	 */
	public static void select()
	{
		for(int i=0;i<s.length;i++)
		{
			int min=i;
			for(int j=i+1;j<s.length;j++)
			{
				if(s[min].getNum()>s[j].getNum())
				{
					min=j;
				}
			}
			if(min!=i)
			{
				SStudent temp=s[i];
				s[i]=s[min];
				s[min]=temp;
			}
		}
		System.out.println("\n选择排序的结果为:"); 
		System.out.print(Arrays.toString(s));
	}
	public static void main(String[] args) 
	{
		//调用对象数组的冒泡排序
		fun();
		//调用对象数组的选择排序
		select();
	      
	}

}

 二叉树排序

package hashMap;
/**
 *二插树的排序
 *@author 郑云飞
 *2010年8月14日
 */
public class BinaryTree
{
	private Node root;//根节点
	public void add(Comparable<?>data)
	{
		Node newNode=new Node(data);//实例化节点类
		if(this.root==null)//没有根节点
		{
			this.root=newNode;//第一个节点作为根节点
		}
		else 
		{
			this.root.addNode(newNode);
		}
	}
	
	public void print()
	{
		this.root.printNode();//输出全部的节点
	}
	class Node
	{
		private Comparable data;//保存操作的数据内容
		private Node leftNode;//左子树
		private Node rightNode;//右子树
		public Node(Comparable<?> data)
		{
			this.data=data;
		}
		public void addNode(Node newNode)
		{
			if(newNode.data.compareTo(this.data)<0)//放在左子树
			{
				if(this.leftNode==null)//还没有左子树,可以直接保存在此节点下的左子树
				{
					this.leftNode=newNode;//保存左子树
				}
				else 
				{
					this.leftNode.addNode(newNode);//向下继续判断
				}
			}
			if(newNode.data.compareTo(this.data)>0)//放在右子树
			{
				if(this.rightNode==null)//还没有左子树,可以直接保存在此节点下的右子树
				{
					this.rightNode=newNode;//保存右子树
				}
				else 
				{
					this.rightNode.addNode(newNode);//向下继续判断
				}
			}
			
		}
		public void printNode()//采用中序遍历
		{
			if(this.leftNode!=null)//存在左子树
			{
				this.leftNode.printNode();//继续找到下面的左子树
			}
			System.out.println(this.data);//找到根内容
			if(this.rightNode!=null)//存在右子树
			{
				this.rightNode.printNode();//继续找到下面的右子树
			}
		}
		
	}
	public static void main(String[] args)
	{
		BinaryTree bt=new BinaryTree();
		bt.add(3);
		bt.add(5);
		bt.add(1);
		bt.add(0);
		bt.add(9);
		bt.add(1);
		bt.print();
		
	}
}

 快速排序

package d;
/**
 * 快速排序
 * 后比前 ：临<前 交换 e--
 * 			不交换  s++
 * 前比后: 临>后  交换 s++
 *           不交换    e--
* 只有插入排序是稳定的
 */

public class Sort_quick
{
	public static void main(String[] args)
	{
		int []a= {5,8,2,7,9,6,4};
		quick_sort(a,0,a.length-1);
		for(int i=0;i<a.length;i++)
		{
			System.out.print(a[i]+" ");
		}
	}

	private static void quick_sort(int[] a,int begin,int end)
	{
		if(begin<end)
		{
			int spos=begin;
			int epos=end;
			int temp=a[spos];
			boolean turn=false;//交换的标志:turn=flase从前往后比，turn=true从后往前比
			while(spos<epos)
			{
				if(!turn)//从前往后比
				{
					if(temp>a[epos])
					{
						swap(a,spos, epos);
						spos++;
						turn=true;
					}
					else
					{
						epos--;
					}
				}
				else //从后往前比
				{
					if(temp<a[spos])
					{
						swap(a, spos, epos);
						epos--;
						turn=false;
					}
					else 
					{
						spos++;
					}
				}
			}
			quick_sort(a, begin, spos-1);
			quick_sort(a, spos+1, end);
		}
	}

	private static void swap(int[] a, int spos, int epos)
	{
		int t=a[spos];
		a[spos]=a[epos];
		a[epos]=t;
	}
	
}

 用容器实现高级排序算法

package hashMap;
import java.util.ArrayList;
import java.util.List;

class MM
{
	int age;
	String name;
	public  MM(int age,String name)
	{
		this.age=age;
		this.name=name;
		
	}
	public String toString()
	{
		return "姓名:"+name+"年龄:"+age;
	}
}
public class A
{
	private static List<MM> al=new ArrayList<MM>();
	 
	public static void main(String[] args)
	{
		al.add(new MM(52,"zhuang zi"));
		al.add(new MM(32,"xun zi"));
		al.add(new MM(42,"kong zi"));
		al.add(new MM(12,"meng zi"));
		al.add(new MM(22,"lao zi"));
		quick_sort(0,(al.size()-1));
		System.out.println(al);
		if(binary_sort(52)!=-1)
		{
			System.out.println("找到元素所在的下标是:"+binary_sort(52));
			System.out.println("找到元素的值"+al.get(binary_sort(52)));
		}
		else 
		{
			System.out.println("没有找到该元素");
		}
	}
	private static void quick_sort(int begin,int end)
	{
		/*****************对象数组的快速排序*******************/
		
		/**
		 * 快速排序的规则
		 * 从前往后比较:前>临 交换:s++
		 *  				 不交换 e--
		 *  从后往前比较 前<临 交换: e--
		 *                   不交换 s++
		 */
		if(begin<end)
		{
			int spos=begin;//起始坐标
			int epos=end;//结束坐标
			MM temp=al.get(spos);
			boolean turn=false;//定义转换的标志
			while(spos<epos)//前面的坐标小于后面的坐标时 ，一直循环
			{
				if(!turn)//从前往后比较
				{
					if(temp.name.compareTo(al.get(epos).name)>0)
					{
						//交换
						
						swap(spos, epos);
						turn=true;
						spos++;
					}
					else
					{
						epos--;
					}
				}
				else
				{
					if(temp.name.compareTo(al.get(spos).name)<0)
					{
						swap(spos, epos);
						turn=false;
						epos--;
						
					}
					else
					{
						spos++;
					}
				}
				quick_sort(begin,spos-1);
				quick_sort(spos+1,end);
			}
		}
		
	}

	private static void swap(int spos, int epos)
	{
		MM mm=al.get(spos);
		al.set(spos, al.get(epos));
		al.set(epos, mm);
	}
	/**********************************折半查找或二分法查找容器中的元素*********************/
	private static int binary_sort(int index)
	{
		
		int start=0;
		int end=al.size()-1;
		int temp=(start+end)/2;
		while(start<=end)
		{
			if(index>al.get(temp).age)
			{
				start=temp+1;
			}
			if(index<al.get(temp).age)
			{
				end=temp-1;
			}
			else 
			{
				return temp;
			}
			temp=(start+end)/2;
		}
		return -1;
	}
}