算法培训(一)---排序算法

排序算法有很多种，一个算法的好坏主要看它的空间复杂度和时间复杂度，而很多时候，我们不会在意空间复杂度，因为我们现在的计算机内存非常大，不用在意这一点空间的消耗。下面说一下几种常用的排序算法。
冒泡排序，选择排序，插入排序，鸡尾酒排序，希尔排序，快速排序(填坑法,双指针法)

• 冒泡排序

    package 算法第一节;
    //冒泡排序
    public class Sort1 {
    	public static void main(String[] args){
    		int [] a = {6,8,1,9,7,5,3,2,10,4};
    		sort(a);
    		for(int i=0;i<10;i++)
    		{
    			System.out.println(" "+a[i]);
    		}
    	}
    	public static void sort(int a[])
    	{
    		for(int i=0;i<10;i++)
    		{
    			for(int j=0;j<10-i-1;j++)
    			{
    				if(a[j]>a[j+1])
    				{
    					int temp=0;
    					temp = a[j];
    					a[j] = a[j+1];
    					a[j+1] = temp;
    				}
    			}
    		}
    	}
    }
  

• 选择排序

    package 算法第一节;
    //选择排序
    public class Sort2 {
    	public static void main(String[] args){
    		int [] a = {6,8,1,9,7,5,3,2,10,4};
    		for(int i=0;i<10;i++)
    		{
    			int min=i;
    			for(int j=i+1;j<10;j++)
    			{
    				if(a[min]>a[j])
    				{
    					min = j;
    				}
    			}
    			swap(a,min,i);
    			System.out.println(a[i]);
    		}
    	}
    	public  static void swap(int a[],int min,int i)
    	{
    		int temp;
    		temp = a[min];
    		a[min] = a[i];
    		a[i]=temp;
    	}
    }
  

• 插入排序

    package 算法第一节;
    //插入排序
    public class Sort3 {
    	public static void main(String[] args){
    		int [] a = {6,8,1,9,7,5,3,2,10,4,2,2,0,6,52,26,2,03,6,1};
    		for(int i=0;i<a.length;i++)
    		{
    				for(int j=i;j>0&&a[j]<a[j-1];j--) 
    				{
    					swap(a,j,j-1);
    				}
    		}
    		for(int i=0;i<a.length;i++)
    		{
    			System.out.println(a[i]);
    		}
    	}
    	public static void swap(int a[],int m,int n)
    	{
    		int temp;
    		temp = a[m];
    		a[m] = a[n];
    		a[n] = temp;
    	}
    }
  

• 鸡尾酒排序

    package 算法第一节;
    //鸡尾酒排序法
    public class Sort4 {
    	public static void main(String[] arg){
    		int [] a = {6,8,1,9,7,5,3,2,10,4};
    		sort(a);
    		for(int i=0;i<10;i++)
    		{
    			System.out.println(" "+a[i]);
    		}
    	}
    	public static void sort(int a[])
    	{
    		int start = 0;
    		int end = 9;
    		while(start<end)
    		{
    			for(int j=start;j<end;j++)
    			{
    				if(a[j]>a[j+1])
    				{
    					int temp=0;
    					temp = a[j];
    					a[j] = a[j+1];
    					a[j+1] = temp;
    				}
    			}
    			end--;
    			for(int j=end;j>start;j--)
    			{
    				if(a[j]<a[j-1])
    				{
    					int temp=0;
    					temp = a[j];
    					a[j] = a[j-1];
    					a[j-1] = temp;
    				}
    			}
    			start++;
    		}
    	}
    }
  

• 希尔排序

    package 算法第一节;
    //希尔排序
    public class Sort5 {
    	public static void main(String[] arg){
    		int [] a = {9,5,7,4,1,6,3,0,2,8};
    		sort5(a);
    		for(int i=0;i<a.length;i++)
    		{
    			System.out.println(a[i]);
    		}
    	}
    	public static void sort5(int []a) {
    		int gap = a.length/2;
    		while(gap>=1) {
    			for(int i=gap;i<a.length;i++) {
    				int temp = a[i];
    				int j = i-gap;
    				while(j>=0&&temp<a[j])
    				{
    					a[j+gap]=a[j];
    					j = j - gap;
    				}
    				a[j+gap] = temp;
    			}
    			gap/=2;
    		}
    	}
    //	public static void swap(int a[],int m,int n)
    //	{
    //		int temp;
    //		temp = a[m];
    //		a[m] = a[n];
    //		a[n] = temp;
    //	}
    }
  

• 快速排序—填坑法

    package 算法第一节;
    //快速排序---填坑法
    public class Sort6 {
    	public static void main(String[] arg){
    		int [] a = {8,2,1,5,7,9,0,3,4,6};
    		int start=0;
    		int end=a.length-1;
    		quickSort(a,start,end);
    		for(int i=0;i<a.length;i++)
    		{
    			System.out.println(a[i]);
    		}
    		
    	}
    public static int Partition(int [] a,int start,int end)
    {
    	int pivot = a[start];
    	while(start<end){
    		while(start<end&&pivot<a[end])
    			end--;
    		a[start] = a[end];
    		while(start<end&&pivot>=a[start])
    			start++;
    		a[end] = a[start];
    	}
    	a[start] = pivot;
    	return start;
    }
    public static void quickSort(int [] a,int start,int end)
    {
    	if(start<end)
    	{
    		int pos = Partition(a,start,end);
    		quickSort(a,start,pos-1);
    		quickSort(a,pos+1,end);
    	}
    }
    }
  

• 快速排序—双指针法

    package 算法第一节;
    //快速排序---双指针法 
    public class Sort7 {
    	public static void main(String[] arg){
    		int [] a = {8,2,1,5,7,9,0,3,4,6};
    		int start=0;
    		int end=a.length-1;
    		quickSort(a,start,end);
    		for(int i=0;i<a.length;i++)
    		{
    			System.out.println(a[i]);
    		}
    	}
    	    public static void quickSort(int[] arr, int start, int end) {
    	        if (start >= end) {
    	            return;
    	        }
    	        //基准位置默认地一个元素
    	        int pivot = arr[start];
    	        int left = start;
    	        int right = end;
     
            while (right > left) {
                //右指针循环左移
                while (left < right && arr[right] > pivot) {
                    right--;
                }
     
                //左指针循环右移
                while (left < right && arr[left] <= pivot) {
                    left++;
                }
                if(left<right){
                    int tem = arr[left];
                    arr[left] = arr[right];
                    arr[right] = tem;
                }
            }
            //基准位置与重合时left与right交换
            int tem = arr[left];
            arr[left]  = pivot;
            arr[start] = tem;
            quickSort(arr, start, left - 1);
            quickSort(arr, left + 1, end);
        }
    }
  

测试多组数组排序，几种方法出现了差异。测试时随机数的产生也会影响测试时间。