Question

我想知道这两个代码如何给出相同的结果。但是逻辑是不同的。

都进行排序。但是两种代码中都有不同类型的分区。怎么定义的。

有人可以向我解释一下吗？

来源：https://www.geeksforgeeks.org/quick-sort/

/* C++ implementation of QuickSort */
#include <bits/stdc++.h> 
using namespace std; 

// A utility function to swap two elements 
void swap(int* a, int* b) 
{ 
    int t = *a; 
    *a = *b; 
    *b = t; 
} 

/* This function takes last element as pivot, places 
the pivot element at its correct position in sorted 
array, and places all smaller (smaller than pivot) 
to left of pivot and all greater elements to right 
of pivot */
int partition (int arr[], int low, int high) 
{ 
    int pivot = arr[high]; // pivot 
    int i = (low - 1); // Index of smaller element 

    for (int j = low; j <= high - 1; j++) 
    { 
        // If current element is smaller than the pivot 
        if (arr[j] < pivot) 
        { 
            i++; // increment index of smaller element 
            swap(&arr[i], &arr[j]); 
        } 
    } 
    swap(&arr[i + 1], &arr[high]); 
    return (i + 1); 
} 

/* The main function that implements QuickSort 
arr[] --> Array to be sorted, 
low --> Starting index, 
high --> Ending index */
void quickSort(int arr[], int low, int high) 
{ 
    if (low < high) 
    { 
        /* pi is partitioning index, arr[p] is now 
        at right place */
        int pi = partition(arr, low, high); 

        // Separately sort elements before 
        // partition and after partition 
        quickSort(arr, low, pi - 1); 
        quickSort(arr, pi + 1, high); 
    } 
} 

/* Function to print an array */
void printArray(int arr[], int size) 
{ 
    int i; 
    for (i = 0; i < size; i++) 
        cout << arr[i] << " "; 
    cout << endl; 
} 

// Driver Code 
int main() 
{ 
    int arr[] = {10, 7, 8, 9, 1, 5}; 
    int n = sizeof(arr) / sizeof(arr[0]); 
    quickSort(arr, 0, n - 1); 
    cout << "Sorted array: \n"; 
    printArray(arr, n); 
    return 0; 
}

第二个代码摘自：https://www.youtube.com/watch?v=7h1s2SojIRw 第二个代码是

    #include <stdio.h>

 #include<stdlib.h>

 void swap(int * x, int * y) {
   int temp = * x;
   * x = * y;
   * y = temp;
 }
 int partition(int A[], int l, int h) {
   int pivot = A[l];
   int i = l, j = h;
   do {
     do {
       i++;
     } while (A[i] <= pivot);
     do {
       j--;
     } while (A[j] > pivot);
     if (i < j) swap( & A[i], & A[j]);
   } while (i < j);
   swap( & A[l], & A[j]);
   return j;
 }
 void QuickSort(int A[], int l, int h) {
   int j;
   if (l < h) {
     j = partition(A, l, h);
     QuickSort(A, l, j);
     QuickSort(A, j + 1, h);
   }

 }
 int main() {
   int A[] = {
     11,
     13,
     7,
     12,
     16,
     9,
     24,
     5,
     10,
     3
   }, n = 10, i;
   QuickSort(A, n);
   for (i = 0; i < 10; i++) printf("%d ", A[i]);
   printf("\n");
   return 0;
 }

Answer 1

但是什么让你如此好奇？
第一个代码使用Lomuto分区，第二个代码（如您在长行中所见）使用Hoare的分区。您可以在Wiki Quicksort page或许多算法书籍中了解有关这些分区的详细信息。

但是两种分区算法都提供了主要结果-较少的元素在左侧移动，较大的元素在右侧移动，并且分区函数返回分隔符元素的索引。

主要的Quicksort例程可以使用提供所需种类的元素分隔的任何分区子例程。请注意，中间状态可能有所不同，但最终结果应该相似。

快速分类代码之间的区别

1 个答案: