关闭

数据结构值排序算法(三)-快速排序

标签: 快速排序数据结构排序算法
2513人阅读 评论(1) 收藏 举报
分类:
基本思想:

快速排序采用的思想是分治思想。

第一趟排序:快速排序是找出一个元素(理论上可以随便找一个)作为基准(pivot),然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值,如此作为基准的元素调整到排序后的正确位置。

递归排序:第二步就是对高段位和地段为两部分进行递归排序。

一趟快速排序的算法的步骤是:
1)设置两个变量low、high,排序开始的时候:low=0,high=N-1;
2)以第一个数组元素作为关键数据,赋值给key,即key=A[0];
3)从high开始向前搜索,即由后开始向前搜索(high--),找到第一个小于key的值A[high],将A[high]和A[low]互换;
4)从i开始向后搜索,即由前开始向后搜索(low++),找到第一个大于key的A[low],将A[low]和A[high]互换;
5)重复第3、4步,直到low=high

一趟快速排序的算法的图解是:


QuickSortClass.java

public class QuickSortClass {
   private int[] array;

   public int[] getArray() {
	   return array;
   }

   public void setArray(int[] array) {
	   this.array = array;
   }
   //快速排序  
   public void quikSort(){  
       QuikSort(0,array.length-1);  
   }  
 
   //递归的快速排序 
   private void QuikSort(int low,int high){  
       if(low>=high){  
              return;  
       }else{  
              int pivot = array[low];  //以第一个元素为基准  
              int partition =partition(low,high,pivot);  //对数组进行划分,比pivot小的元素在低位段,比pivot大的元素在高位段  
              
              QuikSort(low,partition-1);   //对划分后的低位段进行快速排序  
              QuikSort(partition+1,high);  //对划分后的高位段进行快速排序  
       }  
   }  
 

   //以pivot为基准对下标low到high的数组进行划分 ,low 数组段的最小下标 ,high 数组段的最大下标 , pivot 划分的基准元素 , 划分完成后基准元素所在位置的下标 
   private int partition(int low,int high,int pivot){  
        
       while(low<high){               
              while(low<high &&array[high]>=pivot){  //从右端开始扫描,定位到第一个比pivot小的元素  
                     high--;  //如果array[high]比基准pivot大,就不管,继续向前移动
              }  
              swap(low,high);  //如果array[high]比基准pivot小,就交换low和high
               
              while(low<high &&array[low]<=pivot){  //从左端开始扫描,定位到第一个比pivot大的元素  
                     low++;    //如果array[low]比基准pivot小,就不管,继续向后移动
              }  
              swap(low,high);  //如果array[low]比基准pivot大,就交换low和high 
               
       }  
       return low;  
        
}  
   //交换数组中两个元素的数据 
   private void swap(int low,int high){  
       int temp = array[high];  
       array[high] = array[low];  
       array[low] = temp;  
   }  
}


TestQuickSort.java

public class TestQuickSort {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
       int[] list={25,24,6,65,11,43,22,51};
       QuickSortClass qs=new QuickSortClass();
       System.out.println("快排前的数组是:");
       for(int i=0;i<list.length;i++){
    	   System.out.print(list[i]+" ");
       }
      qs.setArray(list);
      qs.quikSort();
      int[] list2= qs.getArray();
       System.out.println();
       System.out.println("快排后的数组是:");
       for(int i=0;i<list2.length;i++){
    	   System.out.print(list2[i]+" ");
       }
	}
}


算法分析:

在最差的情况下,划分有n个元素构成的数组需要进行n次比较和n次移动,因此划分所需的时间为O(n).在最差的情况下,每次主元会将数组划分成为一个大数组和一个空数组。这个大数组的规模是在上次划分的基础上减一。该算法需要(n-1)+(n-2)+...+2+1=O(n2).

在最佳的情况下,每次主元会将数组划分成为规模大致相等的部分。设T(n)标识使用快速排序算法堆包含n个元素的数组排序所需要的时间,因此

                        T(n)=T(n/2)+T(n/2)+n

快速排序的T(n)=O(nlogn)


2
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:370727次
    • 积分:6495
    • 等级:
    • 排名:第3854名
    • 原创:280篇
    • 转载:17篇
    • 译文:0篇
    • 评论:83条
    博客专栏
    最新评论