• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

【共享】C#实现所有经典排序算法汇总

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

1、选择排序


class SelectionSorter    
{    
    
private int min;    
    
public void Sort(int[] arr)    
    {    
        
for (int i = 0; i < arr.Length - 1++i)    
        {    
            min 
= i;    
            
for (int j = i + 1; j < arr.Length; ++j)    
            {    
                
if (arr[j] < arr[min])    
                    min 
= j;    
            }    
            
int t = arr[min];    
            arr[min] 
= arr[i];    
            arr[i] 
= t;    
        }    
    }    
 

2、冒泡排序

class EbullitionSorter    
{    
    
public void Sort(int[] arr)    
    {    
        
int i, j, temp;    
        
bool done = false;    
        j 
= 1;    
        
while ((j < arr.Length) && (!done))//判断长度    
        {    
            done 
= true;    
            
for (i = 0; i < arr.Length - j; i++)    
            {    
                
if (arr[i] > arr[i + 1])    
                {    
                    done 
= false;    
                    temp 
= arr[i];    
                    arr[i] 
= arr[i + 1];//交换数据    
                    arr[i + 1= temp;    
                }    
            }    
            j
++;    
        }    
    }  
    

3、快速排序

class QuickSorter    
{    
    
private void swap(ref int l, ref int r)    
    {    
        
int temp;    
        temp 
= l;    
        l 
= r;    
        r 
= temp;    
    }    
    
public void Sort(int[] list, int low, int high)    
    {    
        
int pivot;//存储分支点    
        int l, r;    
        
int mid;    
        
if (high <= low)    
            
return;    
        
else if (high == low + 1)    
        {    
            
if (list[low] > list[high])    
                swap(
ref list[low], ref list[high]);    
            
return;    
        }    
        mid 
= (low + high) >> 1;    
        pivot 
= list[mid];    
        swap(
ref list[low], ref list[mid]);    
        l 
= low + 1;    
        r 
= high;    
        
do   
        {    
        
while (l <= r && list[l] < pivot)    
            l
++;    
        
while (list[r] >= pivot)    
            r
--;    
            
if (l < r)    
                swap(
ref list[l], ref list[r]);    
        } 
while (l < r);    
        list[low] 
= list[r];    
        list[r] 
= pivot;    
        
if (low + 1 < r)    
            Sort(list, low, r 
- 1);    
        
if (r + 1 < high)    
            Sort(list, r 
+ 1, high);    
    }   
   
}    

4、插入排序 

public class InsertionSorter    
{    
    
public void Sort(int[] arr)    
    {    
        
for (int i = 1; i < arr.Length; i++)    
        {    
            
int t = arr[i];    
            
int j = i;    
            
while ((j > 0&& (arr[j - 1> t))    
            {    
                arr[j] 
= arr[j - 1];//交换顺序    
                --j;    
            }    
            arr[j] 
= t;    
        }    
    }  
   
}    

5、希尔排序 

public class ShellSorter    
{    
    
public void Sort(int[] arr)    
    {    
        
int inc;    
        
for (inc = 1; inc <= arr.Length / 9; inc = 3 * inc + 1) ;    
        
for (; inc > 0; inc /= 3)    
        {    
            
for (int i = inc + 1; i <= arr.Length; i += inc)    
            {    
                
int t = arr[i - 1];    
                
int j = i;    
                
while ((j > inc) && (arr[j - inc - 1> t))    
                {    
                    arr[j 
- 1= arr[j - inc - 1];//交换数据    
                    j -= inc;    
                }    
                arr[j 
- 1= t;    
            }    
        }    
    } 
  
}   

6、归并排序
http://www.cnblogs.com/architect/archive/2009/05/06/1450489.html 

7、基数排序

        //基数排序
        public int[] RadixSort(int[] ArrayToSort, int digit)
        {   
            
//low to high digit
            for (int k = 1; k <= digit; k++)
            {       
                
//temp array to store the sort result inside digit
                int[] tmpArray = new int[ArrayToSort.Length]; 
                
//temp array for countingsort 
                int[] tmpCountingSortArray = new int[10]{0,0,0,0,0,0,0,0,0,0};        
                
//CountingSort        
                for (int i = 0; i < ArrayToSort.Length; i++)        
                {           
                    
//split the specified digit from the element 
                    int tmpSplitDigit = ArrayToSort[i]/(int)Math.Pow(10,k-1- (ArrayToSort[i]/(int)Math.Pow(10,k))*10
                    tmpCountingSortArray[tmpSplitDigit] 
+= 1
                }         
                
for (int m = 1; m < 10; m++)      
                {            
                    tmpCountingSortArray[m] 
+= tmpCountingSortArray[m - 1];        
                }        
                
//output the value to result      
                for (int n = ArrayToSort.Length - 1; n >= 0; n--)       
                {           
                    
int tmpSplitDigit = ArrayToSort[n] / (int)Math.Pow(10,k - 1- (ArrayToSort[n]/(int)Math.Pow(10,k)) * 10;           
                    tmpArray[tmpCountingSortArray[tmpSplitDigit]
-1= ArrayToSort[n];            
                    tmpCountingSortArray[tmpSplitDigit] 
-= 1;       
                }        
                
//copy the digit-inside sort result to source array       
                for (int p = 0; p < ArrayToSort.Length; p++)       
                {           
                    ArrayToSort[p] 
= tmpArray[p];       
                }   
            }    
            
return ArrayToSort;
        }

8、计数排序
the value arrange in input array</param>
        
/// <returns></returns>
        public int[] CountingSort(int[] arrayA, int arrange)
        {    
            
//array to store the sorted result,  
            
//size is the same with input array. 
            int[] arrayResult = new int[arrayA.Length];    
            
//array to store the direct value in sorting process   
            
//include index 0;    
            
//size is arrange+1;    
            int[] arrayTemp = new int[arrange+1];    
            
//clear up the temp array    
            for(int i = 0; i <= arrange; i++)    
            {        
                arrayTemp[i] 
= 0;  
            }    
            
//now temp array stores the count of value equal  
            for(int j = 0; j < arrayA.Length; j++)   
            {       
                arrayTemp[arrayA[j]] 
+= 1;   
            }    
            
//now temp array stores the count of value lower and equal  
            for(int k = 1; k <= arrange; k++)   
            {       
                arrayTemp[k] 
+= arrayTemp[k - 1];  
            }     
            
//output the value to result    
            for (int m = arrayA.Length-1; m >= 0; m--)   
            {        
                arrayResult[arrayTemp[arrayA[m]] 
- 1= arrayA[m];    
                arrayTemp[arrayA[m]] 
-= 1;  
            }    
            
return arrayResult;
        }

9、小根堆排序

        private void ExchageValue(ref double A, ref double B)
        {
            
double Temp = A;
            A 
= B;
            B 
= Temp;
        }

鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
[CF797C]Minimalstring-贪心,栈发布时间:2022-07-13
下一篇:
C#使用HttpWebRequest与HttpWebResponse模拟用户登录发布时间:2022-07-13
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap