排序算法之选择排序--Java语言

选择排序是一种原地的排序算法，适用于小文件。由于选择操作是基于键值的且交换操作只在需要时执行，所以选择排序常用于数值较大和键值较小的文件

选择排序的优点：

a.算法简单，易于实现

b.原地排序(不需要额外的存储空间)

选择排序的缺点：

扩展性较差，时间复杂度较高。

算法步骤：

1.从开始位置作为当前位置，求当前位置之后序列的最小值，与当前位置的值比较，较小值留在当前位置

2.将当前位置往后移一位，重复上述操作，直到当前位置

代码实现：

package selectionsort;



public class Selection {
	
	//选择排序的思想跟冒泡排序的思路很相似，冒泡排序每次都是两两比较元素，将较大元素往后推，最大值便推到第n个元素位置上，并更新n=n-1；
	//而选择排序则从i=0开始寻找i~n-1所对应元素的最小值，找到最小值与i所对应的元素替换，更新i=i+1；
	public static int[] selectionSort(int[] A,int n)
	{
		int min,temp;
		for(int i=0;i<n-1;i++)
		{
			min=i;
			for(int j=i+1;j<n;j++)
			{
				if(A[j]<A[min])
					min=j;
			}
			temp=A[min];
			A[min]=A[i];
			A[i]=temp;
			print(A);
		}
		return A;
	}
	private static void print(int[] A)
	{
		int n=A.length;
		for(int i=0;i<n;i++)
			System.out.print(A[i]+" ");
		System.out.println();
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] A= {9,7,19,1,28,63,16,15};
		int n=8;
		System.out.println("排序中元素移动的步骤：");
		int[] ans=Selection.selectionSort(A, n);
		System.out.println("完成排序后的序列：");
		for(int i=0;i<n-1;i++)
			System.out.print(ans[i]+" ");
		System.out.print(ans[n-1]);


	}

}

测试结果：

排序中元素移动的步骤：
1 7 19 9 28 63 16 15 
1 7 19 9 28 63 16 15 
1 7 9 19 28 63 16 15 
1 7 9 15 28 63 16 19 
1 7 9 15 16 63 28 19 
1 7 9 15 16 19 28 63 
1 7 9 15 16 19 28 63 
完成排序后的序列：
1 7 9 15 16 19 28 63

由上述实践可知，当上述排序好之后依然执行操作，时间复杂度为O（n^2）,因此对算法进行改进，通过引入一个flag，来判断是否进行交换操作，如果没有进行交换操作，则说明排序完成。

改进代码：

package selectionsort;



public class Selection {
	
	//选择排序的思想跟冒泡排序的思路很相似，冒泡排序每次都是两两比较元素，将较大元素往后推，最大值便推到第n个元素位置上，并更新n=n-1；
	//而选择排序则从i=0开始寻找i~n-1所对应元素的最小值，找到最小值与i所对应的元素替换，更新i=i+1；
	public static int[] selectionSort(int[] A,int n)
	{
		int min,temp;
		
		for(int i=0;i<n-1;i++)
		{
			boolean flag=false;
			min=i;
			for(int j=i+1;j<n;j++)
			{
				if(A[j]<A[min])
				{
					min=j;
					flag=true;
				}
			}
			if(flag)
			{
				temp=A[min];
				A[min]=A[i];
				A[i]=temp;
				print(A);
			}
			
		}
		return A;
	}
	private static void print(int[] A)
	{
		int n=A.length;
		for(int i=0;i<n;i++)
			System.out.print(A[i]+" ");
		System.out.println();
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] A= {9,7,19,1,28,63,16,15};
		int n=8;
		System.out.println("排序中元素移动的步骤：");
		int[] ans=Selection.selectionSort(A, n);
		System.out.println("完成排序后的序列：");
		for(int i=0;i<n-1;i++)
			System.out.print(ans[i]+" ");
		System.out.print(ans[n-1]);


	}

}

测试结果：

排序中元素移动的步骤：
1 7 19 9 28 63 16 15 
1 7 9 19 28 63 16 15 
1 7 9 15 28 63 16 19 
1 7 9 15 16 63 28 19 
1 7 9 15 16 19 28 63 
完成排序后的序列：
1 7 9 15 16 19 28 63

当序列是完全有序的，则复杂度是线性的，利用改进的代码只需完成一趟排序即可。例如将A={1,2,3,4,5,6,7,8}代入改进后的代码，进行观察结果：

排序中元素移动的步骤：
完成排序后的序列：
1 2 3 4 5 6 7 8

上述结果移动元素步骤中并无内容，说明第一趟比较中并无交换位置，说明序列本身有序，只需遍历一遍序列即结束排序。

转载请注明：转自http://blog.csdn.net/carson0408/article/details/78648831