新年散分，回帖均有分，顺便收集排序算法

Question

新的一年已经开始了，在此祝大家新年快乐！在新的一年里工作更上一层楼！顺便在这里收集一些排序算法，以int数组为例，条件是不要用Sort方法，否则一个Array.Sort()就搞定了。我先发一个冒泡排序的算法（稍微优化了一下）：        private int[] ArraySort(int[] array)
        {
            int temp;
            bool noSwap = true;
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (array[i] > array[j])
                    {
                        temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                        noSwap = false;
                    }
                }
                if (noSwap) return array;//没有再发生交换，排序结束
                else noSwap = true;
            }
            return array;
        }

Answer 1

heh ,又多学了一招。
谢谢lz
新年快乐

Answer 2

路过
private static void Shell_Sort(int[] b)
        {
            int[] a = new int[b.Length];
            b.CopyTo(a, 0);
        int key;
        Console.WriteLine("Shell排序");
        int gap=5,k;
        for(;gap>0;gap/=2)
                for (int j = gap; j < 10; j++)
                {
                    if (a[j] < a[j - gap])
                    {
                        key = a[j];
                        for (k = j - gap; k >= 0 ; k -= gap)
                        {
                            if (key < a[k])
                            {
                                a[k + gap] = a[k];
                            }
                            else
                                break;
                        }
                        a[k + gap] = key;                    }
                }            Print(a);
        }
原先有一个输出比较次数和交换次数的
我刚才删除了那部分了.....

Answer 3

/**
 * 插入排序数组
 * @author Edwin
 * @version 1.1
 */
public class InsertionArray {
 /**
  * 插入排序数组
  * @param lngArr为要排序的数组
  */
    public void insertionSort(long[]lngArr)
       {
    int intOut=0,intIn=0,intElems=lngArr.length;
       for(intOut=1; intOut<intElems; intOut++)
          {
          long temp = lngArr[intOut]; 
          intIn = intOut; 
          while(intIn>0 && lngArr[intIn-1] >= temp) 
             {
           lngArr[intIn] = lngArr[intIn-1];
              --intIn; 
             }
          lngArr[intIn] = temp;
          }  // end for
       }     // end insertionSort()
 
}---------------------------------------------------------
等会更精彩！！！！！

Answer 4

再来一个折半排序：        private int[] ArraySort(int[] array)
        {
            int i, low, high, mid, j, temp;
            for (i = 1; i < array.Length; ++i)
            {
                temp = array[i];
                low = 0;
                high = i - 1;
                while (low <= high)
                {
                    mid = (low + high) / 2;//折半
                    if (temp < array[mid])
                        high = mid - 1;//插入低半区
                    else low = mid + 1;//插入高半区
                }
                for (j = i - 1; j >= high + 1; --j)//记录后移
                    array[j + 1] = array[j];//插入
                array[high + 1] = temp;
            }
            return array;
        }

Answer 5

同上面
原先有一个输出比较次数和交换次数的 
我刚才删除了那部分了.....
        private static void Select_Sort(int[] b)
           {
            int[] a = new int[b.Length];
            b.CopyTo(a, 0);
        Console.WriteLine("选择排序");
        int min,temp;
        for(int i=0;i<9;i++)
        {
        min=i;
                for (int j = i + 1; j < 10; j++)
                {
                    if (a[min] > a[j])
                        min = j;
                }
        if(min!=i)               
                           {         temp=a[i];
        a[i]=a[min];
        a[min]=temp;
        }
        }
            Print(a);
        }

Answer 6

快速排序：
private int[] m_arrValue = new int[100];
/// <summary>
/// 进行快速排序
/// </summary>
/// <param name="nLow">排序起始元素索引</param>
/// <param name="nHigh">排序结束元素索引</param>
private void QuickSort(int nLow, int nHigh)
{
    int nPivotPos = 0;
    if (nLow < nHigh)
    {
        nPivotPos = this.Partition(nLow, nHigh);
        this.QuickSort(nLow, nPivotPos - 1);
        this.QuickSort(nPivotPos + 1, nHigh);
    }
}/// <summary>
/// 执行一趟快速排序过程
/// </summary>
/// <param name="nLow">一趟快速排序的起始元素索引</param>
/// <param name="nHigh">一趟快速排序的结束元素索引</param>
/// <returns>枢轴元素索引</returns>
private int Partition(int nLow, int nHigh)
{
    int pivotValue = this.m_arrValue[nLow];
    while (nLow < nHigh)
    {
        while (nLow < nHigh && this.m_arrValue[nHigh] >= pivotValue)
            nHigh--;
        if (nLow < nHigh)
            this.m_arrValue[nLow++] = this.m_arrValue[nHigh];
        while (nLow < nHigh && this.m_arrValue[nLow] <= pivotValue)
            nLow++;
        if (nLow < nHigh)
            this.m_arrValue[nHigh--] = this.m_arrValue[nLow];
    }
    this.m_arrValue[nLow] = pivotValue;
    return nLow;
}

Answer 7

happy 牛 year````````````````````````

Answer 8

╭┘└┘└╮
└┐．．┌┘────╮
╭┴──┤          ├╮
│ｏ　ｏ│          │ ● 
╰─┬─╯          │
          HAPPY 牛 YEAR 

Answer 9

n趟m路排序二叉平衡树红黑树B树------------------------------

Answer 10

简单一点void quickSort(char* arr,int startPos, int endPos) 
{ 
int i,j; 
char ch; 
ch=arr[startPos]; 
i=startPos; 
j=endPos; 
while(i<j) 
{ 
  while(arr[j>=ch && i<j)--j; 
    arr=arr[j]; 
  while(arr<[i]=ch && i<j)++i; 
    arr[j]=arr[i];   
} 
arr[i]=ch; 
if(i-1>startPos) quickSort(arr,startPos,i-1); 
if(endPos>i+1) quickSort(arr,i+1,endPos); 
} 

Answer 11

好像错了吧:-)        private int[] ArraySort(int[] array)
        {
            int temp;
            bool noSwap = true;
            for (int i = 0; i < array.Length; i++)
            {
                noSwap=true;
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (array[i] > array[j])
                    {
                        temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                        noSwap = false;
                    }
                }
                if (noSwap) return array;//没有再发生交换，排序结束
                else noSwap = true;
            }
            return array;
        }

Answer 12

http://conan77.vicp.net
happy new year

Answer 13

选择排序 
using System； namespace SelectionSorter 
{ 
public class SelectionSorter 
{ 
private int min； 
public void Sort（int [] list） 
{ 
for（int i=0；i＜list.Length-1；i++） 
{ 
min=i； 
for（int j=i+1；j＜list.Length；j++） 
{ 
if（list[j]＜list[min]） 
min=j； 
} 
int t=list[min]； 
list[min]=list[i]； 
list[i]=t； 
} } 
} 
public class MainClass 
{ 
public static void Main（） 
{ 
int[] iArrary=new int[]{1,5,3,6,10,55,9,2,87,12,34,75,33,47}； 
SelectionSorter ss=new SelectionSorter（）； 
ss.Sort（iArrary）； 
for（int m=0；m＜iArrary.Length；m++） 
Console.Write（"{0} ",iArrary[m]）； 
Console.WriteLine（）； } 
} 
} 
 插入排序 
using System； namespace InsertionSorter 
{ 
public class InsertionSorter 
{ 
public void Sort（int [] list） 
{ 
for（int i=1；i＜list.Length；i++） 
{ 
int t=list[i]； 
int j=i； 
while（（j＞0）&&（list[j-1]＞t）） 
{ 
list[j]=list[j-1]； 
--j； 
} 
list[j]=t； 
} } 
} 
public class MainClass 
{ 
public static void Main（） 
{ 
int[] iArrary=new int[]{1,13,3,6,10,55,98,2,87,12,34,75,33,47}； 
InsertionSorter ii=new InsertionSorter（）； 
ii.Sort（iArrary）； 
for（int m=0；m＜iArrary.Length；m++） 
Console.Write（"{0}",iArrary[m]）； 
Console.WriteLine（）； 
} 
} 
} 
 

Answer 14

再来一个选择排序：
        private int[] ArraySort(int[] array)
        {
            int min, temp;
            for (int i = 0; i < array.Length; i++)
            {
                min = i;
                for (int j = i; j < array.Length; j++)
                {
                    if (array[min] > array[j])
                        min = j;
                }
                temp = array[min];
                array[min] = array[i];
                array[i] = temp;
            }
            return array;
        }

Answer 15

╭┘└┘└╮ 
└┐．．┌┘────╮ 
╭┴──┤          ├╮ 
│ｏ　ｏ│          │ ● 
╰─┬─╯          │ 
          HAPPY 牛 YEAR 

Answer 16

╭┘└┘└╮ 
└┐．．┌┘────╮ 
╭┴──┤          ├╮ 
│ｏ　ｏ│          │ ● 
╰─┬─╯          │ 
          HAPPY 牛 YEAR

Answer 17

选择排序 c++写的
int SELECTIONSORT(long int A[],int n)
{
count[1]=0;
int i,j,k,x;
for(i=1;i<=n;i++)
{
k=i;
for(j=i+1;j<=n;j++)
{
if(A[j]<A[k])k=j;
count[1]++;
}
if(k!=i)
{
x=A[i];
A[i]=A[k];
A[k]=x;
}
}
return 0;
}

Answer 18

c++写的 快速排序
int SPLIT(long int A[],int low,int high)
{
int i,j;
long int x,y;
i=low;
x=A[low];
for(j=low+1;j<=high;j++)
{
if(A[j]<=x)
{
i=i+1;
if(i!=j)
{
y=A[i];
A[i]=A[j];
A[j]=y;
}
count[4]++;
}
} y=A[low];
A[low]=A[i];
A[i]=y;
return i;}
int QUICKSORT(long int A[],int low,int high)
{
int w;
if(low<high)
{
w=SPLIT(A,low,high);
QUICKSORT(A,low,w-1);
QUICKSORT(A,w+1,high);
}
return 0;
}

Answer 19

╭┘└┘└╮ 
└┐．．┌┘────╮ 
╭┴──┤          ├╮ 
│ｏ　ｏ│          │ ● 
╰─┬─╯          │ 
          HAPPY 牛 YEAR 

Answer 20

private int[] ArraySort(int[] array)
        {
            int temp;
            bool noSwap = true;
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (array[i] > array[j])
                    {
                        temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                        noSwap = false;
                    }
                }
                if (noSwap) return array;//没有再发生交换，排序结束
                else noSwap = true;
            }
            return array;
        }哈哈，jf