选择排序（直接选择和堆排序）

package com.panda.sort;

//定义一个数据项
public class Item implements Comparable<Item>{
	int data;
	String flag;		//标志 如果有两个相同的数据
	public Item(int data,String flag)
	{
		this.data=data;
		this.flag=flag;
	}
	public String toString()
	{
		return data+flag;
	}
	public int compareTo(Item other)
	{
		return this.data>other.data?1:
			(this.data==other.data?0:-1);
	}
}
package com.panda.sort;

//直接选择排序
//直接选择排序就是从i（0）下标开始选择一个数，
//然后将该数依次和和面的数比较
//然后将第i个最大或者最小的数找出来
//然后交换放到第i个位置上。
//直接选择排序是稳定排序
public class SelectSort {
	public void selectSort(Item[] data)
	{
		int length=data.length;
		Item temp=null;
		for(int i=0;i<length-1;i++)
		{
			for(int j=i+1;j<length;j++)
			{
				if(data[i].compareTo(data[j])>0)
				{
					//minIndex=j;
					temp=data[i];
					data[i]=data[j];
					data[j]=temp;
				}
			}
			System.out.println("第"+i+"趟排序"+java.util.Arrays.toString(data));
		}
	}
	//改进版，减少非必要的交换
	//但是算法会变成不稳定
	public void selectSort2(Item[] data)
	{
		int length=data.length;
		Item temp=null;
		int minIndex=0;
		for(int i=0;i<length-1;i++)
		{	
						minIndex=i;
			for(int j=i+1;j<length;j++)
			{
				if(data[minIndex].compareTo(data[j])>0)
				{
					minIndex=j;
				}
			}
			if(minIndex!=i)
			{
				temp=data[i];
				data[i]=data[minIndex];
				data[minIndex]=temp;
			}
			System.out.println("第"+i+"趟排序"+java.util.Arrays.toString(data));
		}
	}
}
package com.panda.sort;

public class test {
	public static void main(String[] args)
	{
		SelectSort sort=new SelectSort();
		Item[] data={
				new Item(21,""),
				new Item(30,""),
				new Item(49,""),
				new Item(30,"*"),
				new Item(16,""),
				new Item(9,"")
		};
		System.out.println("排序之前"+java.util.Arrays.toString(data));
		sort.selectSort(data);
		System.out.println("排序之后"+java.util.Arrays.toString(data));
		System.out.println("改进版：");
		Item[] data2={
				new Item(21,""),
				new Item(30,""),
				new Item(49,""),
				new Item(30,"*"),
				new Item(16,""),
				new Item(9,"")
		};
		sort.selectSort2(data2);
		System.out.println("排序之后"+java.util.Arrays.toString(data2));
	}
}

输出结果：

排序之前[21, 30, 49, 30*, 16, 9]
第0趟排序[9, 30, 49, 30*, 21, 16]
第1趟排序[9, 16, 49, 30*, 30, 21]
第2趟排序[9, 16, 21, 49, 30, 30*]
第3趟排序[9, 16, 21, 30, 49, 30*]
第4趟排序[9, 16, 21, 30, 30*, 49]
排序之后[9, 16, 21, 30, 30*, 49]
改进版：
第0趟排序[9, 30, 49, 30*, 16, 21]
第1趟排序[9, 16, 49, 30*, 30, 21]
第2趟排序[9, 16, 21, 30*, 30, 49]
第3趟排序[9, 16, 21, 30*, 30, 49]
第4趟排序[9, 16, 21, 30, 30*, 49]
排序之后[9, 16, 21, 30, 30*, 49]

对排序

package com.panda.sort;
/*堆排序
 * 
 * */
public class HeapSort {
	public void MinheapSort(Item[] data)
	{
		int length=data.length;
		for(int i=0;i<length-1;i++)
		{
			//建堆
			builMinHeap(data,length-1-i);
			//交换堆顶和最后一个元素
			swap(data,0,length-1-i);
			System.out.println(java.util.Arrays.toString(data));
		}
	}
	public void MaxheapSort(Item[] data)
	{
		int length=data.length;
		for(int i=0;i<length-1;i++)
		{
			//建堆
			builMaxHeap(data,length-1-i);
			//交换堆顶和最后一个元素
			swap(data,0,length-1-i);
			System.out.println(java.util.Arrays.toString(data));
		}
	}
	//建立最小堆
	public void builMinHeap(Item[] data,int lastIndex)
	{
		int k=0;	//第i个结点
		int samllerIndex;//三个结点中，那个结点最大
		for(int i=(lastIndex-1)/2;i>=0;i--)
		{
			k=i;
			//表示k存在子节点
			while(k*2+1<=lastIndex)
			{
				samllerIndex=k*2+1;
				if(samllerIndex<lastIndex)
				{
					//存在右结点
					if(data[samllerIndex].compareTo(data[samllerIndex+1])>0)
					{
						samllerIndex+=1;
					}
				}
				//如果k结点比biggerIndex结点小，则交换
				if(data[k].compareTo(data[samllerIndex])>0)
				{
					//交换
					swap(data,k,samllerIndex);
					//将biggerIndex赋给k，开始while循环的下次循环
					//重新保证k节点大于左右节点的值
					k=samllerIndex;
				}else{
					break;
				}
			}
		}
	}
	//建立最大堆
	public void builMaxHeap(Item[] data,int lastIndex)
	{
		int k=0;	//第i个结点
		int biggerIndex;//三个结点中，那个结点最大
		for(int i=(lastIndex-1)/2;i>=0;i--)
		{
			k=i;
			//表示k存在子节点
			while(k*2+1<=lastIndex)
			{
				biggerIndex=k*2+1;
				if(biggerIndex<lastIndex)
				{
					//存在右结点
					if(data[biggerIndex].compareTo(data[biggerIndex+1])<0)
					{
						biggerIndex+=1;
					}
				}
				//如果k结点比biggerIndex结点小，则交换
				if(data[k].compareTo(data[biggerIndex])<0)
				{
					//交换
					swap(data,k,biggerIndex);
					//将biggerIndex赋给k，开始while循环的下次循环
					//重新保证k节点大于左右节点的值
					k=biggerIndex;
				}else{
					break;
				}
			}
		}
	}
	private void swap(Item[] data,int i,int j)
	{
		Item temp=data[i];
		data[i]=data[j];
		data[j]=temp;
	}
}
package com.panda.sort;

public class test {
	public static void main(String[] args)
	{
		HeapSort sort=new HeapSort();
		Item[] data={
				new Item(21,""),
				new Item(30,""),
				new Item(49,""),
				new Item(30,"*"),
				new Item(16,""),
				new Item(9,"")
		};
		System.out.println("最大堆排序");
		System.out.println("排序之前"+java.util.Arrays.toString(data));
		sort.MaxheapSort(data);
		System.out.println("排序之后"+java.util.Arrays.toString(data));
		System.out.println("最小堆排序：");
		Item[] data2={
				new Item(21,""),
				new Item(30,""),
				new Item(49,""),
				new Item(30,"*"),
				new Item(16,""),
				new Item(9,"")
		};
		sort.MinheapSort(data2);
		System.out.println("排序之后"+java.util.Arrays.toString(data2));
	}
}

输出结果：

最大堆排序
排序之前[21, 30, 49, 30*, 16, 9]
[9, 30, 21, 30*, 16, 49]
[16, 30*, 21, 9, 30, 49]
[9, 16, 21, 30*, 30, 49]
[9, 16, 21, 30*, 30, 49]
[9, 16, 21, 30*, 30, 49]
排序之后[9, 16, 21, 30*, 30, 49]
最小堆排序：
[49, 16, 21, 30*, 30, 9]
[30, 30*, 21, 49, 16, 9]
[49, 30*, 30, 21, 16, 9]
[30, 49, 30*, 21, 16, 9]
[49, 30, 30*, 21, 16, 9]
排序之后[49, 30, 30*, 21, 16, 9]