排序1---冒泡法：
单向冒泡排序的基本原理就是：对于给定的n个数据，从第一个数据开始一次对相邻的两个数据进行比较，当前面的数据大于后面的数据时，交换位置，进行一轮比较和换位后，n个数据中最大的那个被排在最后，即第n位。然后对前面n-1个数据进行第二次比较，重复该过程。
package com.etc.jichu;
public class MaoPaoPaiXuDemo1
{
public static int[] maopaoSort(int[] a)
{
int length=a.length;
int i,j,temp;
for(i=length-1;i>0;i--)
{ //第一次限制在0-9循环，第二次限制在0-8循环，依次降低
for(j=0;j<i;j++)
{
if(a[j]>a[j+1])
{ //将大的数字放在a[j+1]
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
return a;
}
public static void main(String[] args)
{
int a[]={6,9,17,8,73,12,56,49,56,60};
a=maopaoSort(a);
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
}
}
========================================================================
排序2---插入法：
思想：
1.在原始数据中，将第一个数据作为已排序的数据序列
2.从数组中获取下一个元素，在已经排序好的元素中从后向前扫描，并判断该元素与已排列好的的大小
3.若排序序列的元素大于新元素，则将该元素移到下一位置
4.重复步骤三，直到找到已排序的元素小于或者等于新元素的位置
5.将新元素插入到该位置
6.重复步骤2~5，直到数据处理完毕
栗子：
【38,65,97,76,13,27,49】
排序过程
第一趟插入38：【38,65,97,76,13,27,49】
第二趟插入65：【38,65,97,76,13,27,49】
第三趟插入97：【38,65,97,76,13,27,49】
第四趟插入76：【38,65,76,97,13,27,49】
第五趟插入13：【13,38,65,76,97,27,49】
第六趟插入27：【13,27,38,65,76,97,49】
第七趟插入49：【13,27,38,49,65,76,97】
package com.etc.jichu;
public class ChaRuPaiXu
{
public static int[] charuSort(int[] a)
{
int length=a.length;
int i,j,tmp;
for(i=1;i<length;i++)
{
tmp=a[i]; //取出一个未排序的数据
for(j=i-1;j>=0&&a[j]>tmp;j--)
{ //在排序序列中查找位置
a[j+1]=a[j]; //数据向后移动，无须担心被覆盖，因为tmp以保存第一个被覆盖的数据
}
a[j+1]=tmp; //插入数据，因为上面的for循环最后执行了一次j--，所以赋值时a[j+1]
}
return a;
}
public static void main(String[] args)
{
int a[]={22,94,20,28,17,41,35,14,83,66};
a=charuSort(a);
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
}
}
==============================================================================
排序3---快速排序法：
思想：
1.在一列数组中，选择其中一个数据作为“基准”。
2.所有小于“基准”的数据，都移到“基准”的左边，所有大于“基准”的数据，都移到“基准”的右边。
3.对于“基准”左边和右边的两个子集，不断重复第一步和第二步。直到所有的数据子集只剩下一个数据为止。
栗子：
现有一组数据如下：
[ 8 , 2 , 6 , 4 , 1 , 3 , 9 , 5 ]
第一步：（假如选4为基准）,
[ 8 , 2 , 6 , 4 , 1 , 3 , 9 , 5 ]
第二步：将每个数据与4对比，"<=4"左边，“>4”放右边。
[ 2 , 1 , 3 ] 4 [ 8 , 6 , 9 , 5 ]
第三步：两个子数组，重复第一步选“选基准”和第二步“放置数据”。4的位置后面都不会动的。
[ 2 , 1 , 3 ] 4 [ 8 , 6 , 9 , 5 ]
1 [ 2 , 3 ] 4 [ 5 ] 6 [ 8 , 9 ]
最后：
[ 1 , 2 , 3 , 4 , 5 , 6 , 8 , 9 ]
package com.etc.jichu;
public class KuaiSuPaiXu
{
public static void kuaiSuSort(int[] array,int low,int high)
{
if(low>high) //一定要有这句
{
return;
}
int i=low,j=high;
int index=array[i]; //index为"基准"
while(i<j)
{
while(i<j&&array[j]>=index)
{ //寻找到array[j]<index，即发现小于基准值的数字，才退出，此时寻找到的数字的下标为j
j--;
}
if(i<j)
{
array[i]=array[j]; //将找到的那个小于基准值的数字覆盖了array[i]，原先的array[i]存储在基准值index中
i++; //i下标右移
}
while(i<j&&array[i]<index)
{ //寻找>=基准值的数字array[i],退出循环
i++;
}
if(i<j)
{ ////将找到的那个大于或等于基准值的数字覆盖了array[j]，此时array[i]会有重复了
array[j]=array[i];
j--;
}
} //这个一次循环结束：1.所有小于index的数字会都在index左边，所有大于或等于index的数字会在右边
array[i]=index; //array[i]位置固定好了，刚好覆盖重复的那个值
kuaiSuSort(array,low,i-1); //递归左边的小于index但未排序的数据
kuaiSuSort(array,i+1,high); //递归右边的大于index但未排序的数据
}
public static void quickSort(int[] array)
{
kuaiSuSort(array,0,array.length-1);
}
public static void main(String[] args)
{
int a[]={26,49,30,88,27,31,85,64,33,86};
quickSort(a);
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
}
}
============================================================================
排序4---选择排序法：
思想：
对于给定的一组数据，经过第一轮比较后得到最小的数据，然后将该数据与第一个数据的位置进行交换；
然后对不包括第一个数据以外的其它数据进行第二轮比较，得到最小的数据并与第二个数据进行位置交换；
重复该过程，直到进行比较的数据只有一个时为止。
栗子：
待排序数组
【38,65,97,76,13,27,49】
排序过程
第一趟：【13,65,97,76,38,27,49】
第二趟：【13,27,97,76,38,65,49】
第三趟：【13,27,38,76,97,65,49】
第四趟：【13,27,38,49,97,65,76】
第五趟：【13,27,38,49,65,97,76】
第六趟：【13,27,38,49,65,76,97】
最后结果：【13,27,38,49,65,76,97】
package com.etc.jichu;
public class XuanZePX
{
public static int[] xzSort(int[] a)
{
int length=a.length; //先得到数组的长度
int i,j,n,tmp,flag;
for(i=0;i<length;i++)
{
tmp=a[i]; //tmp为每次循环的第一个位置
flag=i;
for(j=i+1;j<length;j++)
{
if(tmp>a[j])
{
tmp=a[j]; //这一步不要忘记了，因为tmp不一定是最小的，必须用循环过的最小的和当前的数据比较
flag=j; //如果发现比tmp小的数据，将flag标记为当前位置，循环结束，flag标志的是最小数字的下标
}
}
if(flag!=i)
{ //如果flag已经不再是刚开始第一个位置的i，那么将两者的数据调换位置
n=a[i];
a[i]=a[flag];
a[flag]=n;
}
}
return a;
}
public static void main(String[] args)
{
int a[]={21,49,20,28,67,13,53,64,23,66};
a=xzSort(a);
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
}
}
==========================================================================
排序5---归并排序法：
思想：
对于给定的一组数据（假设有n个数据），首先将每两个相邻长度为1的子序列进行归并，得到n/2个长度为2或者1的有序子序列，再将其两两合并，反复此过程，得到一个有序序列。
public class TestMergeSort {
//目的就是将一个数组分成两组，按从小到大顺序排列后重新组合成新数组，即“并”
public static void mergeArray(int[] a,int first,int mid,int last,int[] temp){
int i=first,j=mid+1;
int m=mid,n=last; //以mid为分界点，将a[]分为两组 : a[i...m]和a[j...n]
int k=0;
while(i<=m&&j<=n){ //其中一个条件不满足，可能就是一个数组的数据全部赋值到temp中，另一个还有残留数据
if(a[i]<=a[j]){
temp[k++]=a[i++];
}else{
temp[k++]=a[j++];
}
}
while(i<=m){
temp[k++]=a[i++];
}
while(j<=n){
temp[k++]=a[j++];
}
for(i=0;i<k;i++){ //将temp[]中的排序好的值 重新放回 a[]
a[first+i]=temp[i];
}
}
//利用递归的方式拆开数据，即“归”
public static void mergeSort(int a[],int first,int last,int[] temp){
if(first<last){ //这里的last是最后一个数据的位置坐标，比长度小1
int mid=(first+last)/2; //寻找中间的位置坐标值
mergeSort(a,first,mid,temp); //左边有序
mergeSort(a,mid+1,last,temp); //右边有序
mergeArray(a,first,mid,last,temp); //有序之后合并
}
}
public static void mergeSortFinal(int[] a){ //传入一个数据即可
int last=a.length; //这里的last是长度
int[] temp = new int[last];
mergeSort(a,0,last-1,temp);
}
public static void main(String[] args){
int a[]={2,9,0,8,7,1,5,4,3,6};
mergeSortFinal(a);
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
=================================================================================
排序6---希尔排序法：
思想：
1.选择一个步长序列T1,T2,T3...,Tk，满足Ti>Tj(i<j),Tk=1。（步长：即每次插入排序的步长）
2.按步长序列的个数K，对待排序序列进行K趟排序。
3.每趟排序，根据对应的步长Ti，对待排序列分割成Ti个子序列，分别对子序列进行插入排序。
public class TestShellSort {
public static void shellSort(int[] array){
int length=array.length;
int i,j;
int h; //h为每次的步长
int temp;
for(h=length/2;h>0;h=h/2){ //步长每次减小为原来的1/2
for(i=h;i<length;i++){ //从array[h]开始，往后。第一次即从中间位置往后开始,第二次往后挪一位
temp=array[i]; //保存数据至temp
for(j=i-h;j>=0;j=j-h){ //第一次j从0开始，结束该循环。第二次进入该循环j从1开始，因为i增加1了，这段代码保证每次都是步长为h的两个数据在比较
if(temp<array[j]){ //如果发现比temp大的数据，将该数据放置在位置array[j+h]
array[j+h]=array[j];
}else{
break;
}
}
array[j+h]=temp;
}
}
}
public static void main(String[] args){
int a[]={2,9,0,8,7,1,5,4,3,6};
shellSort(a);
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
===========================================================================