sortthd.cpp
上传用户:lulishicai
上传日期:2010-03-01
资源大小:13202k
文件大小:5k
源码类别:

Delphi/CppBuilder

开发平台:

C++ Builder

  1. //----------------------------------------------------------------------------
  2. //Borland C++Builder
  3. //Copyright (c) 1987, 1998-2002 Borland International Inc. All Rights Reserved.
  4. //----------------------------------------------------------------------------
  5. //---------------------------------------------------------------------
  6. #include <vcl.h>
  7. #pragma hdrstop
  8. #include "sortthd.h"
  9. //---------------------------------------------------------------------
  10. void __fastcall PaintLine(TCanvas *Canvas, int I, int Len)
  11. {
  12.   TPoint points[2];
  13.   points[0] = Point(0, I*2+1);
  14.   points[1] = Point(Len, I*2+1);
  15.   Canvas->Polyline(EXISTINGARRAY(points));
  16. }
  17. //---------------------------------------------------------------------
  18. __fastcall TSortThread::TSortThread(TPaintBox *Box, int *SortArray, 
  19.     const int SortArray_Size)
  20.     : TThread(False)
  21. {
  22.   FBox = Box;
  23.   FSortArray = SortArray;
  24.   FSize = SortArray_Size + 1;
  25.   FreeOnTerminate = True;
  26. }
  27. //---------------------------------------------------------------------
  28. /* Since DoVisualSwap uses a VCL component (i.e., the TPaintBox) it should never
  29.   be called directly by this thread.  DoVisualSwap should be called by passing
  30.   it to the Synchronize method which causes DoVisualSwap to be executed by the
  31.   main VCL thread, avoiding multi-thread conflicts. See VisualSwap for an
  32.   example of calling Synchronize. */
  33. void __fastcall TSortThread::DoVisualSwap()
  34. {
  35.   TCanvas *canvas;
  36.   canvas = FBox->Canvas;
  37.   canvas->Pen->Color = TColor(clBtnFace);
  38.   PaintLine(canvas, FI, FA);
  39.   PaintLine(canvas, FJ, FB);
  40.   canvas->Pen->Color = clRed;
  41.   PaintLine(canvas, FI, FB);
  42.   PaintLine(canvas, FJ, FA);
  43. }
  44. //---------------------------------------------------------------------
  45. /* VisusalSwap is a wrapper on DoVisualSwap making it easier to use.  The
  46.   parameters are copied to instance variables so they are accessable
  47.   by the main VCL thread when it executes DoVisualSwap */
  48. void __fastcall TSortThread::VisualSwap(int A, int B, int I, int J)
  49. {
  50.   FA = A;
  51.   FB = B;
  52.   FI = I;
  53.   FJ = J;
  54.   Synchronize(DoVisualSwap);
  55. }
  56. //---------------------------------------------------------------------
  57. /* The Execute method is called when the thread starts */
  58. void __fastcall TSortThread::Execute()
  59. {
  60.   Sort(FSortArray, FSize-1);
  61. }
  62. //---------------------------------------------------------------------
  63. __fastcall TBubbleSort::TBubbleSort(TPaintBox *Box, int *SortArray, 
  64.   const int SortArray_Size)
  65.   : TSortThread(Box, SortArray, SortArray_Size)
  66. {
  67. }
  68. //---------------------------------------------------------------------
  69. void __fastcall TBubbleSort::Sort(int *A, int const AHigh)
  70. {
  71.   int I, J, T;
  72.   for (I=AHigh; I >= 0; I--)
  73.     for (J=0; J<=AHigh-1; J++)
  74.       if (A[J] > A[J + 1])
  75.       {
  76.         VisualSwap(A[J], A[J + 1], J, J + 1);
  77.         T = A[J];
  78.         A[J] = A[J + 1];
  79.         A[J + 1] = T;
  80.         if (Terminated)
  81.           return;
  82.       }
  83. }
  84. //---------------------------------------------------------------------
  85. __fastcall TSelectionSort::TSelectionSort(TPaintBox *Box, int *SortArray, 
  86.   const int SortArray_Size)
  87.   : TSortThread(Box, SortArray, SortArray_Size)
  88. {
  89. }
  90. //---------------------------------------------------------------------
  91. void __fastcall TSelectionSort::Sort(int *A, int const AHigh)
  92. {
  93.   int I, J, T;
  94.   for (I=0; I <= AHigh-1; I++)
  95.     for (J=AHigh; J >= I+1; J--)
  96.       if (A[I] > A[J])
  97.       {
  98.         VisualSwap(A[I], A[J], I, J);
  99.         T = A[I];
  100.         A[I] = A[J];
  101.         A[J] = T;
  102.         if (Terminated) 
  103.           return;
  104.       }
  105. }
  106. //---------------------------------------------------------------------
  107. __fastcall TQuickSort::TQuickSort(TPaintBox *Box, int *SortArray, 
  108.   const int SortArray_Size)
  109.   : TSortThread(Box, SortArray, SortArray_Size)
  110. {
  111. }
  112. //---------------------------------------------------------------------
  113. void __fastcall TQuickSort::QuickSort(int *A, int const AHigh, int iLo, int iHi)
  114. {
  115.   int Lo, Hi, Mid, T;
  116.   Lo = iLo;
  117.   Hi = iHi;
  118.   Mid = A[(Lo+Hi)/2];
  119.   do
  120.   {
  121.     if (Terminated)
  122.       return; 
  123.     while (A[Lo] < Mid)
  124.         Lo++;
  125.     while (A[Hi] > Mid) 
  126.         Hi--;
  127.     if (Lo <= Hi)
  128.     {
  129.       VisualSwap(A[Lo], A[Hi], Lo, Hi);
  130.       T = A[Lo];
  131.       A[Lo] = A[Hi];
  132.       A[Hi] = T;
  133.       Lo++;
  134.       Hi--;
  135.     }
  136.   }
  137.   while (Lo <= Hi);
  138.   if (Hi > iLo) 
  139.     QuickSort(A, AHigh, iLo, Hi);
  140.   if (Lo < iHi) 
  141.     QuickSort(A, AHigh, Lo, iHi);
  142. }
  143. //---------------------------------------------------------------------
  144. void __fastcall TQuickSort::Sort(int *A, int const AHigh)
  145. {
  146.   QuickSort(A, AHigh, 0, AHigh);
  147. }
  148. //---------------------------------------------------------------------
  149.