简单排序算法汇总（算法四版）

            排序算法是重新排列数组元素的算法，而每一个元素都有一个主键，目的就是将所有元素的主键按照某种方式进行排列（大小或字母顺序）

           我列出排序算法的模板：

                                            sort()方法，将排序代码放在该方法中；

                                            less()方法，对元素进行比较；

                                            exch()方法，将元素交换位置；

                                            show()方法，打印字符数组的内容；

                                            isSorted()方法，测试数组元素是否有序；

                                            main()方法，主要是输入读取字符串，然后将其排序，最后输出； 

            

package Test.com;

import java.util.Scanner;

public class Example
{
	public static void sort(Comparable arr[])
	{
   
	}
	private static boolean less(Comparable v,Comparable w)  //对元素进行比较
	{
		return v.compareTo(w)<0;
	}
	private static void exch(Comparable arr[],int i,int j)  //将元素交换位置
	{
		Comparable t=arr[i];
		  			arr[i]=arr[j];
		  			arr[j]=t;
	}
	private static void show(Comparable arr[])   //打印字符数组内容
	{
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}
	public static boolean isSorted(Comparable arr[])
	{
		for(int i=1;i<arr.length;i++)
			if(less(arr[i],arr[i-1])) return false;
		return true;
	}
	public static void main(String arrgs[])
	{
		/** String arr[]={"S","O","R","T","E","X","A","M","P","L","E"};**/
		Scanner sc=new Scanner(System.in);
		int N;
		N=sc.nextInt();
		String arr[]=new String[N];
		for(int i=0;i<N;i++)
			arr[i]=sc.next();
		sort(arr);//sort()函数名可以根据你所要排序的名字更换
		assert isSorted(arr);
		show(arr);
	}
}

一 选择排序

     选择排序算法流程：首先，找到数组中最小的那个元素，

                                    其次，将它和数组的第一个元素交换位置（若第一个元素为最小，那么它就与自己交换）；

                                    然后，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置；如此重复，直到将整个数组排序；

      时间复杂度为O(n^2)，排序时间与输入无关；

package Test.com;

import java.util.Scanner;

public class Sort 
{
	public static void Selection(Comparable arr[])
	{
		int N=arr.length;    //获取数组长度
		for(int i=0;i<N; i++)
		{
			int min=i;      //设置最小元素的索引号
			for(int j=i+1;j<N;j++)
				if(less(arr[j],arr[min])) min=j;
			exch(arr,i,min);
		}
	}
	public static boolean less(Comparable v,Comparable w)
	{
		return v.compareTo(w)<0;
	}
	public static void exch(Comparable arr[],int i,int j)  //数据进行交换
	{
		Comparable t=arr[i];
					arr[i]=arr[j];
					arr[j]=t;
	}
	public static void show(Comparable arr[])
	{
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}
	public static boolean isSorted(Comparable arr[])
	{
		for(int i=1;i<arr.length;i++)
			if(less(arr[i],arr[i-1])) return false;
		return true;
	}
	public static void main(String[] args)
	{
		Scanner sc=new Scanner(System.in);   //键盘输入字符数组
		int N;
		N=sc.nextInt();
		String arr[]=new String[N];
		for(int i=0;i<N;i++)  
            arr[i]=sc.next();
		/**String arr[]={"S","O","R","T","E","X","A","M","P","L","E"};**/
	   
        Selection(arr);  
        assert isSorted(arr);
        show(arr);

	}
}

二.插入排序

        将想要插入的元素插入到适当的位置，并要为插入的元素腾出空间，然而要将其余所有元素在插入之前都向右移动一位；

package Test.com;

import java.util.Scanner;

public class Insertion
{
	public static void sort(Comparable arr[])
	{
		int N=arr.length;
		for(int i=1;i<N;i++)
		{
			for(int j=i;j>0&&less (arr[j],arr[j-1]);j--)
				exch(arr,j,j-1);
		}
	}
	private static boolean less(Comparable v,Comparable w)  //对元素进行比较
	{
		return v.compareTo(w)<0;
	}
	private static void exch(Comparable arr[],int i,int j)  //将元素交换位置
	{
		Comparable t=arr[i];
		  			arr[i]=arr[j];
		  			arr[j]=t;
	}
	private static void show(Comparable arr[])   //打印字符数组内容
	{
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}
	public static boolean isSorted(Comparable arr[])
	{
		for(int i=1;i<arr.length;i++)
			if(less(arr[i],arr[i-1])) return false;
		return true;
	}
	public static void main(String arrgs[])
	{
		/** String arr[]={"S","O","R","T","E","X","A","M","P","L","E"};**/
		Scanner sc=new Scanner(System.in);
		int N;
		N=sc.nextInt();
		String arr[]=new String[N];
		for(int i=0;i<N;i++)
			arr[i]=sc.next();
		sort(arr);//sort()函数名可以根据你所要排序的名字更换
		assert isSorted(arr);
		show(arr);
	}
}

三.希尔排序
            希尔排序是一种基于插入排序的快速排序的排序算法；

                希尔排序的思想是：使数组中任意间隔为 d 的元素都是有序的。什么意思呢，就是说第1、1+d、1+2d......的元素值都是有序的；

                 希尔排序过程：

                                      1.首先选择一个增量序列；

                                       2.然后按照增量序列个数d,对序列进行d趟排序；

                                      3.每趟排序，根据对应的增量d，将待排序列分割成若干长度为m的子序列，分别对各子序列进行直接插入排序。

package Test.com;

import java.util.Scanner;

public class Shell
{
	public static void shell(Comparable arr[])
	{
		int N=arr.length;
		int d=1;
		while(d<N/3)
			d=3*d+1;
		while(d>=1)
		{
			for(int i=d;i<N;i++)
			{
				for(int j=i;j>=d&&less(arr[j],arr[j-d]);j-=d)
					exch(arr,j,j-d);
			}
			d=d/3;
		}
	}
	public static boolean less(Comparable v,Comparable w)
	{
		return v.compareTo(w)<0;
	}
	public static void exch(Comparable arr[],int i,int j)
	{
		Comparable temp=arr[i];
		           arr[i]=arr[j];
		           arr[j]=temp;
	}
	public static void show(Comparable arr[])
	{
		for(int i=0;i<arr.length;i++)
		    System.out.print(arr[i] +" ");
		System.out.println();
	}
	public static boolean isSorted(Comparable arr[])
	{
		for(int i=1;i<arr.length;i++)
			if(less(arr[i],arr[i-1])) return false;
		return true;
	}
	public static void main(String args[])
	{
		Scanner sc=new Scanner(System.in);
		int N;
		N=sc.nextInt();
		String arr[]=new String[N];
		for(int i=0;i<N;i++)
			arr[i]=sc.next();
		shell(arr);
		assert isSorted(arr);
		show(arr);
		
	}
}

四归并排序

        归并排序的思想：将两个有序的数组归并成一个更大的有序数组；

          先将待排序的序列分为若干个子序列，每个子序列是有序的，然后将有序的子序列合并为整体有序序列；

private static Comparable aux[];   //设置一个归并中所需要的一个辅助数组
	public static void shell(Comparable arr[])
	{
		aux = new Comparable[arr.length];   //给数组aux分配空间
		sort(arr,0,arr.length-1);           
	}
	public static void merge(Comparable arr[] ,int left, int mid, int right)
	{
		int i=left, j=mid+1;      //将i设置为序列开头，j设置为序列中间+1
		for(int k=left; k<=right;k++)
			if(i>mid)               //i的值为左边，如果大于中间点，
				arr[k] = aux[j++];  //将右半边的元素存入数组
			else if (j>right)       //因为j为中间位置+1，当j大于right时，
				arr[k]=aux[i++];    //将取左半边的元素
			else if (less(aux[j],aux[i]))//如果右半边的当前元素小于左半边的当前元素，则取右半边的当前元素
				arr[k]=aux[j++];
			else                        //否则就是：右半边的当前元素大于等于左半边的当前元素，取左半边的元素
				arr[k]=aux[i++];        
	}
	
	private static void sort(Comparable arr[],int sta,int end)
	{
		if(end<=sta)               //为空
			return ;
		int mid = sta+(end-sta)/2; //计算中间位置
		sort(arr,sta,mid);      //排序左半边
		sort(arr,mid+1,end);   //将右半边进行排序
		merge(arr,sta,mid,end); //归并结果
	}