数据结构 排序

1、冒泡排序

基本思想：比较相邻的两个值，大的排后面，小的排到前面，将最大的排都最后面，然后再次循环，不用循环到最后，倒数第二个就行，第二大的排到倒数第二个；即每次比较如果发现较小的元素在后面，就交换两个相邻的元素。时间复杂度为O(n^2)。

参考如下代码：

c语言 

 void bubble_sort(int a[],int n)//n为数组a的元素个数 

{    

 int i,j,temp;     

for(j=0;j<n-1;j++)           

for(i=0;i<n-1-j;i++)           

        {                

if(a[i]>a[i+1])//数组元素大小按升序排列                

            {           

 temp=a[i];                    

   a[i]=a[i+1];                    

 a[i+1]=temp;             

           }        

      }

 }

java 语言

public void bubblesort(){

int  out,in;

for (out=elems-1;out>0;out--) //向外循环

for（in=0;in<out;in++）//向内循环

if（a[in]>a[in+1]）

swap(in,in+1);//交换

}

2、选择排序

基本思想：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。其实，并不急于调换位置，先从A[1]开始逐个检查，看哪个数最小就记下该数所在的位置P，等一躺扫描完毕，再把A[P]和A[1]对调，这时A[1]到A[10]中最小的数据就换到了最前面的位置。 所以，选择排序每扫描一遍数组，只需要一次真正的交换，而冒泡可能需要很多次。时间复杂度为O(n^2)。

参考如下代码：

C 语言

void select_sort(int*a,int n) {   

  int i, j, min, t;     

for( i =0; i < n -1; i ++)

{        

  min = i;        

 for( j = i +1; j < n; j ++)             

if( a[ min]> a[ j])                 

min = j;        

 if( min != i)

{           

  t = a[ min];          

   a[ min]= a[ i];            

a[ i]= t;        

 }    

 } 

}

java语言

public void selectsort(){

int  out,in，min;

for (out=0;out<elems-1;out++) //向外循环

{

min=out;

for（in=out+1;in<elems;in++）//向内循环

if（a[in]<a[min]）

min=in; //新的最小值

swap(out,min);//交换

}

}

3、插入排序

基本思想：就是将一个数据插入到已经排好序的有序数据中（初始时可以认为只有一个元素的序列是有序的序列，即从第二个数据起开始逐个插入），从而得到一个新的、个数加一的有序数据。每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的序列中适当位置上，直到全部插入完为止。适用于少量数据的排序，时间复杂度为O(n^2)。

C语言

void insert_sort(int a[],int n) {   

  int i, j, m;     

for( i =0; i < n ; i ++)

{        

m=a[i];

//将等待插入的元素保存于m

for(j=i; j>0 && a[j-1]>m; j--) // 把比m大的元素后移    

a[j]=a[j-1];

if(j!=i)

a[j]=m; //将m插入j处

}

java 语言

public void insertsort(){

int  out,in;

for (out=1;out<elems;out++) //向外循环

{

long temp=a[out];

in=out;

while(in>0 && a[in-1]>=temp)

{

a[in]=a[in-1];

--in;

}

a[in]=temp;

}

}

4、快速排序

基本思想：在待排序的n个记录中任取一个记录（通常取第一个记录），以该记录为基准，将当前的无序区划分为左右两个较小的无序子区，使左边的记录均小于基准值，右边的记录均大于或等于基准值，基准值位于两个无序区的中间位置（即该记录最终的排序位置）。之后，分别对两个无序区进行上述的划分过程，直到无序区所有记录都排序完毕。时间复杂度为O(nlog2^n)。快速排序（Quicksort）是对冒泡排序的一种改进。

参考代码如下：

C语言

static void swap(int *a, int *b)

 {      

 int temp = *a;     

*a = *b;    

  *b = temp; 

}   

int quickSortNum = 0; 

 static int partition(int a[], int low, int high) 

{     

int privotKey = a[low];  //基准元素     

while(low < high)    

  {  

  //从表的两端交替地向中间扫描           

while(low < high  && a[high] >= privotKey)   // 找到第一个小于privotKey的值             

high--;  //从high所指位置向前搜索，至多到low+1位置          

swap(&a[low], &a[high]);  // 将比基准元素小的交换到低端           

while(low < high  && a[low] <= privotKey)   // 找到第一个大于privotKey的值             

low++;  //从low所指位置向后搜索，至多到high-1位置         

swap(&a[low], &a[high]);  // 将比基准元素大的交换到高端     

}     

quickSortNum++;  // 快速排序趟数加1    

return low;  // 返回基准值所在的位置 

}      

 void QuickSort(int a[], int low, int high){       

if(low < high)   

  {        

  int privotLoc = partition(a, low, high); // 将表一分为二           

QuickSort(a, low, privotLoc-1);          //  递归对低子表递归排序    

QuickSort(a, privotLoc+1, high);         // 递归对高子表递归排序      

  }  

 }

java语言

public class QuickSort { 

public static int Partition(int a[],int p,int r){  

  int x=a[r-1];  

 int i=p-1;  

 int temp;      

for(int j=p;j<=r-1;j++)

{      

 if(a[j-1]<=x)

{        // swap(a[j-1],a[i-1]);       

 i++;       

 temp=a[j-1];       

 a[j-1]=a[i-1];        

a[i-1]=temp;

  }     

 }      //swap(a[r-1,a[i+1-1]);     

  temp=a[r-1];      

a[r-1]=a[i+1-1];      

a[i+1-1]=temp;            

return i+1; 

}    

public static void QuickSort(int a[],int p,int r){     

  if(p<r)

{   

 int q=Partition(a,p,r);    

QuickSort(a,p,q-1);   

 QuickSort(a,q+1,r);      

 }     

}