C 使用 DSA - 快速排序

快速排序是一种高效的排序算法，它基于将数据数组划分为较小数组。将大型数组划分为两个数组，其中一个数组包含小于指定值的数组，指定的这个值称为枢轴，根据枢轴对数组进行划分；另一个数组包含大于枢轴的值。

快速排序对数组进行划分，然后递归调用自身两次，对生成的两个子数组进行排序。此算法对于大型数据集非常有效，因为其平均和最坏情况下的复杂度为 O(nlogn)，其中 n 是项数。

伪代码

A : array of items 

procedure quickSort(left, right)
   if right-left <= 0
      return
   else     
      pivot = A[right]
      partition = partitionFunc(left, right, pivot)
      quickSort(left,partition-1)
      quickSort(partition+1,right)    
   end if		
end procedure

function partitionFunc(left, right, pivot)
   leftPointer = left -1
   rightPointer = right

   while True do
      while A[++leftPointer] < pivot do
         //donothing            
      end while
      while rightPointer > 0 && A[--rightPointer] > pivot do
         //donothing         
      end while
      if leftPointer >= rightPointer
         break
      else                
         swap leftPointer,rightPointer
      end if
   end while      
   swap leftPointer,right
   return leftPointer
end function

procedure swap (num1, num2)
   temp = A[num1]
   A[num1] = A[num2]
   A[num2] = temp;
end procedure

示例

#include <stdio.h>
#include <stdbool.h>
#define MAX 7

int intArray[MAX] = {4,6,3,2,1,9,7};

void printline(int count){
   int i;
   for(i=0;i <count-1;i++){
      printf("=");
   }
   printf("=\n");
}
void display(){
   int i;
   printf("[");
   
   // navigate through all items 
   for(i=0;i<MAX;i++){
      printf("%d ",intArray[i]);
   }
   printf("]\n");
}
void swap(int num1, int num2){
   int temp = intArray[num1];
   intArray[num1] = intArray[num2];
   intArray[num2] = temp;
}
int partition(int left, int right, int pivot){
   int leftPointer = left -1;
   int rightPointer = right;

   while(true){
      while(intArray[++leftPointer] < pivot){
         //do nothing
      }
      while(rightPointer > 0 && intArray[--rightPointer] > pivot){
         //do nothing
      }
      if(leftPointer >= rightPointer){
         break;
      } else {
         printf(" item swapped :%d,%d\n", 
         intArray[leftPointer],intArray[rightPointer]);
         swap(leftPointer,rightPointer);
      }
   }
   printf(" pivot swapped :%d,%d\n", intArray[leftPointer],intArray[right]);
   swap(leftPointer,right);
   printf("Updated Array: "); 
   display();
   return leftPointer;
}
void quickSort(int left, int right){        
   if(right-left <= 0){
      return;   
   } else {
      int pivot = intArray[right];
      int partitionPoint = partition(left, right, pivot);
      quickSort(left,partitionPoint-1);
      quickSort(partitionPoint+1,right);
   }      
}
main(){
   printf("Input Array: ");
   display();
   printline(50);
   quickSort(0,MAX-1);
   printf("Output Array: ");
   display();
   printline(50);
}

输出

如果我们编译并运行上述程序，则会产生以下输出 −

Input Array: [4 6 3 2 1 9 7 ]
==================================================
   pivot swapped :9,7
Updated Array: [4 6 3 2 1 7 9 ]
   pivot swapped :4,1
Updated Array: [1 6 3 2 4 7 9 ]
   item swapped :6,2
   pivot swapped :6,4
Updated Array: [1 2 3 4 6 7 9 ]
   pivot swapped :3,3
Updated Array: [1 2 3 4 6 7 9 ]
Output Array: [1 2 3 4 6 7 9 ]
==================================================