一些排序算法

最近自己闲着没事,写了一些排序算法,有兴趣的来看看吧,不过我没有做具体的优化,不过测试了一下性能凑合事吧 !

//冒泡排序,delphi语言版本

Code
//冒泡排序,delphi语言版本
procedure BubbleSort(var int: array of integer);
var
  temp: Integer;
  I, j: Integer;
  swap: Boolean;
begin
  for I := 0 to Length(int) - 2 do
  begin
    swap := False;
    for j := Length(int) - 1 downto Succ(i) do
    begin
      if int[j] > int[j - 1] then
      begin
        temp := int[j];
        int[j] := int[j - 1];
        int[j - 1] := temp;
        swap := True;
      end;
    end;
    if not swap then
      Exit;
  end;
end;

 

Code
    //冒泡排序java版本
    public static void BubbleSort(int[] intArray)
    {
        int temp;
        boolean    Swap;
        for (int i=0;i<intArray.length-1;i )
        {
            Swap=false;
            for (int j=intArray.length-1;j>i;j--)
            {
                if (intArray[j]>intArray[j-1])
                {
                    temp=intArray[j];
                    intArray[j]=intArray[j-1];
                    intArray[j-1]=temp;
                    Swap=true;
                }
            }
            if (!Swap)
                break;
        }
    }

 

Code
//选择排序delphi版本
procedure SelectionSort(var int: array of Integer);
var
  I: Integer;
  indexOfMin: Integer;
  j: Integer;
  temp: Integer;
begin
  for I := 0 to Length(int) - 2 do
  begin
    indexOfMin := i;
    for j := i 1 to Length(int) - 1 do
    begin
      if int[j] < int[indexOfMin] then
      begin
        indexOfMin := j;
      end;
    end;
    if indexofMin <> i then
    begin
      temp := int[i];
      int[i] := int[indexOfMin];
      int[indexOfMin] := temp;
    end;
  end;
end;

 

Code
    //选择排序
    public static void SelectionSort(int[] intArray)
    {
        int indexOfMin;
        int temp;
        for (int i=0;i<intArray.length-1;i )
        {
            indexOfMin=i;
            for (int j=i 1;j<intArray.length;j )
            {
                if (intArray[j]<intArray[indexOfMin])
                {
                    indexOfMin=j;
                }
            }
            if (indexOfMin!=i)
            {
                temp=intArray[i];
                intArray[i]=intArray[indexOfMin];
                intArray[indexOfMin]=temp;               
            }
        }
    }

 

Code
//插入排序delphi版
procedure InsertSort(var int: array of Integer);
var
  I: Integer;
  Temp: Integer;
  M: Integer;
begin
  for I := 1 to Length(int) - 1 do
  begin
    Temp := int[i];
    M := i;
    while ((M > 0) and (Temp < int[M - 1])) do
    begin
      int[m] := int[m - 1];
      Dec(m);
    end;
    int[M] := Temp;
  end;
end;
//插入排序delphi改进版
procedure InsertSort1(var int:array of Integer);
var
 indexOfMin:Integer;
 temp:Integer;
  I,j: Integer;
begin
 indexOfMin :=0;
 ////////////找到数组中最小的元素////////////
 for I := 1 to Length(int) - 1 do
     begin
       if int[i]<int[indexOfMin] then
          begin
            indexOfMin:=i;
          end;
     end;
 if indexOfMin<>0 then
    begin
      temp:=int[0];
      int[0]:=int[indexOfMin];
      int[indexOfMin]:=temp;
    end;
 for I := 2 to Length(int) - 1 do
   begin
     temp:=int[i];
     j:=i;
     while temp<int[j-1] do
        begin
          int[j]:=int[j-1];
          Dec(j);
        end;
     int[j]:=temp;
   end; 
end; 

 

Code
    //插入排序 java版
    public static void InsertSort(int[] intArray)
    {
        int temp;
        int m;
        for (int i=1;i<intArray.length;i )
        {
            temp=intArray[i];
            m=i;
            while ((m>0)&&(temp<intArray[m-1]))
            {
                intArray[m]=intArray[m-1];
                m--;
            }
            intArray[m]=temp;
        }
    }
    //插入排序--优化
    public static void InsertSort1(int[] intArray)
    {
        int indexOfMin=0;
        int temp;
        int j;
        for (int i=1;i<intArray.length;i )
        {
            if (intArray[i]<intArray[indexOfMin])
            {
                indexOfMin=i;
            }
        }
        if (indexOfMin!=0)
        {
            temp=intArray[0];
            intArray[0]=intArray[indexOfMin];
            intArray[indexOfMin]=temp;
        }
        for (int i=2;i<intArray.length;i )
        {
            temp=intArray[i];
            j=i;
            while (temp<intArray[j-1])
            {
                intArray[j]=intArray[j-1];
                j--;
            }
            intArray[j]=temp;             
        }
    }

 

 

 

    //选择排序
    public static void SelectionSort(int[] intArray)
    {
        int indexOfMin;
        int temp;
        for (int i=0;i<intArray.length-1;i )
        {
            indexOfMin=i;
            for (int j=i 1;j<intArray.length;j )
            {
                if (intArray[j]<intArray[indexOfMin])
                {
                    indexOfMin=j;
                }
            }
            if (indexOfMin!=i)
            {
                temp=intArray[i];
                intArray[i]=intArray[indexOfMin];
                intArray[indexOfMin]=temp;               
            }
        }
    }