数据结构——排序

排序

排序是数据结构很重要的一个内容，实现的方法有很多种；
冒泡排序；
选择排序；//当前元素与之后元素相比较，减少比较次数；时间复杂度O(n^2/2);
插入排序；//当前元素与之前已排序好的序列相比较，插入其中;
{实现方法有两种，1>依次交换该元素与之前元素；2>将已排序元素大于该元素的值依次后移，然后插入（优点：减少比较次数）,排序更加快速}；
归并排序：类似于二分法查找，采用递归思想，自定向下，分而治之;

快速排序：插入排序与归并排序相结合;指定基数，每次以基数为基准，采用“挖坑”，“填补”思想，将序列分为两部分（一部分比基数小，另一部分比基数大），自顶向下，不断递归；

接口：

public interface Sorted {
	//冒泡排序
	public void BubbleSort();
	//选择排序
	public void SelectSort();
	//插入排序
	public void InsertSort();
	public void InsertSortUpdate();
	//归并排序
	public void MergeSort();
	
	public void merge(int [] a,int low,int mid,int high);
	//快速排序
	public void QuickSort(int left,int right);
}

public interface Merge {
	
	public void merge(int [] a,int low,int mid,int hight);
	
	public void sort(int []a,int low,int hight);
}

import java.util.Scanner;


public class SortImpl implements Sorted,Merge {
	
	private int [] a=new int[10];
	public void Input()
	{
		int length=a.length;
		Scanner sc=new Scanner(System.in);
		
		for(int i=0;i<length;i++)
		{
			a[i]=sc.nextInt();
		}
	}
	
	//冒泡排序,O(n^2);
	public void BubbleSort()
	{
		int Length=a.length;
		for(int i=0;i<Length;i++)
		{
			for(int j=0;j<Length;j++)
			{
				if(a[i]>a[j])
				{
					int mid=a[i];
					a[i]=a[j];
					a[j]=a[i];
				}
			}
		}
	}
	
	//选择排序,避免重复比较,O(n^2/2);
	//每次选择未排序序列中最小元素与当前元素交换;
	public void SelectSort()
	{
		int Length=a.length;
		for(int i=0;i<Length;i++)
		{
			int min=i;
			for(int j=i+1;j<Length;j++)//内存循环找到最小值,标记为min;
			{
				if(a[min]>a[j])
				{
					min=j;
				}
			}
			int exchange=a[i];
			a[i]=a[min];
			a[min]=exchange;
		}
	}
	
	//插入排序
	//数组分为3部分；以排序序列，当前节点，未排序部分
	//当前节点之前均为已排序部分，以节点分界;
	public void InsertSort()
	{
		int Length=a.length;
		//a[0~i)为已排序序列,a[i]为待排序节点,a[i+1~length]为待排序序列
		for(int i=1;i<Length;i++)
		{
			for(int j=i;j>0&&a[j]<a[j-1];j--)//j>0防止访问越界;
			{
				int exchange=a[j];
				a[j]=a[j-1];
				a[j-1]=exchange;
			}
		}
	}
	
	public void InsertSortUpdate()
	{
		int Length=a.length;
		for(int i=1;i<Length;i++)
		{
			int exchang=a[i];
			int j=i;
			while(j>0&&a[i]<a[j-1])//or(;j>0&&a[i]<a[j-1];j--),不交换，而是整体右移，较少交换次数，提高速度;
			{
				a[j]=a[j-1];
			}
			a[j]=exchang;
		}
	}
	
	private int [] assist;//临时数组,用于归并排序;
	
	public void sort(int []a,int low,int hight)
	{
		if(hight<=low)//递归基
		{
			return;
		}
		int mid=low+(low+hight)/2;
		sort(a,low,mid);
		sort(a,mid+1,hight);
		merge(a,low,mid,hight);
	}
	public void merge(int [] a,int low,int mid,int hight)
	{
		//将[low,mid],[mid+1,hight]归并;
		int i=low,j=mid+1;//待归并序列边界;
		for(int k=low;k<=hight;k++)
		{
			assist[k]=a[k];
		}
		for(int k=low;k<=hight;k++)
		if(i>mid)//左边用尽;
		{
			a[k]=assist[j++];
		}
		else if(j>hight)//右边用尽
		{
			a[k]=assist[i++];
		}
		else if(a[i]<=a[j])
		{
			a[k]=assist[i++];
		}
		else
			a[k]=assist[j++];
		
	}
	//归并排序
	public void MergeSort()
	{
		assist=new int[a.length];
		sort(a,0,a.length-1);//a.length为哨兵;
	}
	
	
	//快速排序,选取基准数,使序列按照以基准数为中间点,左边均比基准数小,右边均比基准数大，自上向下递归
	
	public void quicksort(int [] a,int left,int right)
	{
		int X=a[left];
		int l=left,r=right;
		while(l<r)
		{
			while(l<r&&X<=a[r])
			{
				r--;
			}
			if(l<r)
			{
				a[l]=a[r];
			}
			while(l<r&&X>a[l])
			{
				l++;
			}
			if(l<r)
			{
				a[r]=a[l];
			}
		}
		a[l]=X;
		quicksort(a,left,l-1);
		quicksort(a,l+1,r);
	}
	public void QuickSort()
	{
		quicksort(a,1,a.length-1);
	}
}