Quick Sort Method

2. #include <stdio.h>
   
4. #include <stdlib.h>
   
8. void swap (int *x,int *y)//exchange function
   
10. {
    
12. int temp;
    
14. temp = *x;
    
16. *x = *y;
    
18. *y = temp;
    
20. }
    
24. int Choose_pivot (int I,int j)//take two number mean function
    
26. {
    
28. Return ((i+j)/2);
    
30. }
    
34. void quicksort (int list[],int m,int n)//quick sort function, m,n are left-bounded right-bound such as 0 and 9 in 10-digit order
    
36. {
    
38. int key,i,j,k;
    
40. If (m < N)
    
42. {
    
44. K = Choose_pivot (m,n); The value of the middle position is obtained
    
46. Swap (&list[m],&list[k]);
    
48. Key = list[m];
    
50. i = m+1;
    
52. j = n;
    
54. While (i <= j)
    
56. {
    
58. While ((i <= n) && (list[i] <= key))
    
60. i++;
    
62. While ((j >= m) && (list[j] > Key)
    
64. j--;
    
66. If (i < J)
    
68. Swap (&list[i],&list[j]);
    
70. }
    
72. Swap the position of two elements
    
74. Swap (&list[m],&list[j]);
    
76. Recursively sort smaller data series
    
78. Quicksort (list,m,j-1);
    
80. Quicksort (list,j+1,n);
    
82. }
    
84. }
    
88. void Printlist (int List[],int n)
    
90. {
    
92. int i;
    
94. For (i=0;i<n;i++)
    
96. printf ("%d\t", list[i]);
    
98. }
    
102. void Main ()
     
104. {
     
106. const int max_elements = 10;
     
108. int list[max_elements];
     
112. int i = 0;
     
114. 
     
116. Generate random numbers of fill sequences
     
118. For (i = 0; I < max_elements; i++) {
     
120. list[i] = Rand ();
     
122. }
     
124. printf ("sequence before sorting: \ n");
     
126. Printlist (list,max_elements);
     
128. 
     
130. Sort the list using quicksort
     
132. Quicksort (list,0,max_elements-1);
     
136. Print the result
     
138. printf ("sequence after sorting using the quick sort algorithm: \ n");
     
140. Printlist (list,max_elements);
     
142. }
2. This procedure is not difficult, it should be very good to understand, I take the process roughly, first of all, you have an array and three pointers, the first pointer is called the P pointer, before the end of the process it is firmly pointed to the first number, the second pointer and the third pointer, respectively, the lo pointer and the Hi pointer, Points to the leftmost value and the rightmost value, respectively. The LO pointer and the hi pointer from both sides of the same time to the middle, in the process of approaching the value of the P pointer, if the value of the LO pointer is smaller than the value of the P pointer, lo++, also small + +, and then small + +, until a value greater than the P pointer, then the sight shift to the Hi pointer, if The value of the Hi pointer is larger than the value of the P pointer, hi--, or Larger----and then large again--until a value less than the P pointer is Encountered. The value of the LO pointer and the value of the Hi pointer are then Swapped. Continue this process until two pointers meet, then the value of the P pointer and the value of the meeting to make a swap, and then return the P pointer to a new Position.

Quick Sort Method