排序算法

一、冒泡排序

思想：从第一个元素开始，对数组中两两相邻的元素比较，将值较小的元素放在前面，值较大的元素放在后面，一轮比较完毕，一个最大的数沉底成为数组中的最后一个元素，一些较小的数如同气泡一样上浮一个位置。n个数，经过n-1轮比较后完成排序。

public static void main(String[] args)
{
int []a={1,5,6,3,4,8,2,0,7,8,40,52,10,11};
int temp;
for(int i=a.length;i>1;i--)
{
for(int j=0;j<i-1;j++)
{
if(a[j]>a[j+1])
{
temp=a[j+1];
a[j+1]=a[j];
a[j]=temp;
}
}
}
for(int i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
}

二、选择排序

思想：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的一端，直到全部待排序的数据元素排完。

public static void main(String[] args) {
// TODO Auto-generated method stub


int []a={1,5,6,3,4,8,2,0,7,8,40,52,10,11};
int temp,k;
for(int i=0;i<a.length;i++)
{
k=i;
for(int j=i+1;j<a.length;j++)
{
if(a[k]>a[j])
{
k=j;
}
}
temp=a[i];
a[i]=a[k];
a[k]=temp;
}
for(int i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
}

三、插入排序

思想：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。

public static void main(String[] args) {
// TODO Auto-generated method stub
int temp=0;
int flag=0;
int j=0;
int []a={10,2,5,4,6,9,0,3};
for(int i=1;i<a.length;i++)
{
flag=a[i];
j=i; 
for(int j1=0;j1<i;j1++)
{
if(a[j1]>flag)
{
while(j1<i)
{
a[i]=a[i-1];
i--;
}
a[i]=flag;
break;
}
}
}
for(int i=0;i<a.length;i++)
System.out.print(a[i]+" ");
}

四、快速排序

思想：过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小， 然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列，如以第一个元素为基准，则第一次排序后的结果为左边的元素都小于第一个元素，右边的元素都大于第一个元素

public static void main(String[] args) {
// TODO Auto-generated method stub


int a[]={4,19,15,6,3,9,7,2};
int start=0,end=7;
quickSort(a,start,end);
System.out.println("排序后的结果是:");
print(a);
}

public static void quickSort(int []a,int s,int e)
{
int temp=a[s];//以第一个数作为基准数
int t=0;
int k=0;
int num=0;
//一躺排序将要排序的数据分割成独立的两部分，左边的部分的数小于基准数，右边的数大于基准数，
for(int i=s+1;i<=e;i++)
{
if(a[i]<temp)//如果比第一个数小
{
k=i;        //记录比基准数小的数的下标
t=a[k]; //记录下此时的值
for(int j=k;j>s;j--)
{
a[j]=a[j-1]; //将比此数之前的数组的值都往后移一位
}
a[s]=t;           //将次数放到基准数的左边
num++;             //记录比基准数小的数的个数
}
else
continue;
}
System.out.println("num="+num);
print(a);
if(s+num-1-s>0)
{
quickSort(a,s,s+num-1);
}
if(e-s-num-1>0)
{
quickSort(a,s+num+1,e);
}
}

public static void print(int[] data) 
{  
        for (int i = 0; i < data.length; i++) 
        {  
            System.out.print(data[i] + "\t");  
        }  
        System.out.println();  
    }  

五、希尔排序

思想：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量

dn=1(dn<....<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

public static void main(String []args)
{
int []a={49,38,65,97,76,13,27,34,12,64,9};
int len=a.length;
int gap = 0;
for(gap=len/2;gap>0;gap/=2)
{
for(int i=0;i<gap;i++)
{
for(int j=i+gap;j<len;j+=gap)
{
if(a[j]<a[j-gap])
{
int temp=a[j];
int k=j-gap;
while(k>=0&&a[k]>temp)
{
a[k+gap]=a[k];
k=k-gap;
}
a[k+gap]=temp;
}
}
}
}

System.out.println("排序后:");
   for(int i=0;i<len;i++)
    System.out.println(a[i]+" ");
}

六、归并排序

思想：分而治之(divide - conquer);每个递归过程涉及三个步骤 
第一, 分解: 把待排序的 n 个元素的序列分解成两个子序列, 每个子序列包括 n/2 个元素. 
第二, 治理: 对每个子序列分别调用归并排序MergeSort, 进行递归操作 
第三, 合并: 合并两个排好序的子序列,生成排序结果. 

public static void main(String[] args) {
int a[]={6,301,202,100,38,8,1};
mergeSort(a);
System.out.println("排序后的数组");
print(a);
}

public static void print(int[] data) {  
       for (int i = 0; i < data.length; i++) {  
           System.out.print(data[i] + "\t");  
       }  
       System.out.println();  
   }  
 
public static void mergeSort(int []data)
{
sort(data,0,data.length-1);
}
 
public static void sort(int []data,int start,int end)
{
System.out.println("start="+start+"end"+end);
int mid=(start+end)/2;
if(start<end)
{
sort(data,start,mid);
sort(data,mid+1,end);
merge(data,start,mid,end);
print(data);
}
}
 
public static void merge(int []data,int s,int m,int e)
{
int []res=new int[e-s+1];
int start=s;
int mid=m+1;
int r=0;
while(start<=m&&mid<=e)
{
if(data[start]<data[mid])
res[r++]=data[start++];
else
res[r++]=data[mid++];
}
while(start<=m)
res[r++]=data[start++];
while(mid<=e)
res[r++]=data[mid++];
for(int r1=0;r1<res.length;r1++)
{
data[r1+s]=res[r1];
}
}