1. 程式人生 > >C#各排序實現方法

C#各排序實現方法

  1     /// <summary>
  2     /// 排序輔助類
  3     /// </summary>
  4     public static class SortExtention
  5     {
  6         /// <summary>
  7         /// 氣泡排序
  8         /// </summary>
  9         /// <param name="arry">要排序的整數陣列</param>
 10         public static void BubbleSort(this int[] arry)
 11         {
 12             for (int i = 0; i < arry.Length; i++)
 13             {
 14                 for (int j = 0; j < arry.Length - 1 - i; j++)
 15                 {
 16                     //比較相鄰的兩個元素,如果前面的比後面的大,則交換位置
 17                     if (arry[j] > arry[j + 1])
 18                     {
 19                         int temp = arry[j + 1];
 20                         arry[j + 1] = arry[j];
 21                         arry[j] = temp;
 22                     }
 23                 }
 24             }
 25         }
 26         /// <summary>
 27         /// 快速排序
 28         /// </summary>
 29         /// <param name="arry">要排序的陣列</param>
 30         /// <param name="left">低位</param>
 31         /// <param name="right">高位</param>
 32         public static void QuickSort(this int[] arry, int left, int right)
 33         {
 34             //左邊索引小於右邊,則還未排序完成   
 35             if (left < right)
 36             {
 37                 //取中間的元素作為比較基準,小於他的往左邊移,大於他的往右邊移   
 38                 int middle = arry[(left + right) / 2];
 39                 int i = left - 1;
 40                 int j = right + 1;
 41                 while (true)
 42                 {
 43                     //移動下標,左邊的往右移動,右邊的向左移動
 44                     while (arry[++i] < middle && i < right) ;
 45                     while (arry[--j] > middle && j > 0) ;
 46                     if (i >= j)
 47                         break;
 48                     //交換位置
 49                     int number = arry[i];
 50                     arry[i] = arry[j];
 51                     arry[j] = number;
 52 
 53                 }
 54                 QuickSort(arry, left, i - 1);
 55                 QuickSort(arry, j + 1, right);
 56             }
 57         }
 58         /// <summary>
 59         /// 直接插入排序
 60         /// </summary>
 61         /// <param name="arry">要排序的陣列</param>
 62         public static void InsertSort(this int[] arry)
 63         {
 64             //直接插入排序是將待比較的數值與它的前一個數值進行比較,所以外層迴圈是從第二個數值開始的
 65             for (int i = 1; i < arry.Length; i++)
 66             {
 67                 //如果當前元素小於其前面的元素
 68                 if (arry[i] < arry[i - 1])
 69                 {
 70                     //用一個變數來儲存當前待比較的數值,因為當一趟比較完成時,我們要將待比較數值置入比它小的數值的後一位 
 71                     int temp = arry[i];
 72                     int j = 0;
 73                     for (j = i - 1; j >= 0 && temp < arry[j]; j--)
 74                     {
 75                         arry[j + 1] = arry[j];
 76                     }
 77                     arry[j + 1] = temp;
 78                 }
 79             }
 80         }
 81         /// <summary>
 82         /// 希爾排序
 83         /// </summary>
 84         /// <param name="arry">待排序的陣列</param>
 85         public static void ShellSort(this int[] arry)
 86         {
 87             int length = arry.Length;
 88             for (int h = length / 2; h > 0; h = h / 2)
 89             {
 90                 //here is insert sort
 91                 for (int i = h; i < length; i++)
 92                 {
 93                     int temp = arry[i];
 94                     if (temp < arry[i - h])
 95                     {
 96                         for (int j = 0; j < i; j += h)
 97                         {
 98                             if (temp < arry[j])
 99                             {
100                                 temp = arry[j];
101                                 arry[j] = arry[i];
102                                 arry[i] = temp;
103                             }
104                         }
105                     }
106                 }
107             }
108         }
109         /// <summary>
110         /// 簡單選擇排序
111         /// </summary>
112         /// <param name="arry">待排序的陣列</param>
113         public static void SimpleSelectSort(this int[] arry)
114         {
115             int tmp = 0;
116             int t = 0;//最小數標記
117             for (int i = 0; i < arry.Length; i++)
118             {
119                 t = i;
120                 for (int j = i + 1; j < arry.Length; j++)
121                 {
122                     if (arry[t] > arry[j])
123                     {
124                         t = j;
125                     }
126                 }
127                 tmp = arry[i];
128                 arry[i] = arry[t];
129                 arry[t] = tmp;
130             }
131         }
132         /// <summary>
133         /// 堆排序
134         /// </summary>
135         /// <param name="arry"></param>
136         public static void HeapSort(this int[] arry, int top)
137         {
138             List<int> topNode = new List<int>();
139 
140             for (int i = arry.Length / 2 - 1; i >= 0; i--)
141             {
142                 HeapAdjust(arry, i, arry.Length);
143             }
144 
145             for (int i = arry.Length - 1; i >= arry.Length - top; i--)
146             {
147                 int temp = arry[0];
148                 arry[0] = arry[i];
149                 arry[i] = temp;
150                 HeapAdjust(arry, 0, i);
151             }
152         }
153         /// <summary>
154         /// 構建堆
155         /// </summary>
156         /// <param name="arry"></param>
157         /// <param name="parent"></param>
158         /// <param name="length"></param>
159         private static void HeapAdjust(int[] arry, int parent, int length)
160         {
161             int temp = arry[parent];
162 
163             int child = 2 * parent + 1;
164 
165             while (child < length)
166             {
167                 if (child + 1 < length && arry[child] < arry[child + 1]) child++;
168 
169                 if (temp >= arry[child])
170                     break;
171 
172                 arry[parent] = arry[child];
173 
174                 parent = child;
175 
176                 child = 2 * parent + 1;
177             }
178 
179             arry[parent] = temp;
180         }
181         /// <summary>
182         /// 歸併排序
183         /// </summary>
184         /// <param name="arry"></param>
185         /// <param name="first"></param>
186         /// <param name="last"></param>
187         public static void MergeSort(this int[] arry, int first, int last)
188         {
189             if (first + 1 < last)
190             {
191                 int mid = (first + last) / 2;
192                 MergeSort(arry, first, mid);
193                 MergeSort(arry, mid, last);
194                 Merger(arry, first, mid, last);
195             }
196         }
197         /// <summary>
198         /// 歸併
199         /// </summary>
200         /// <param name="arry"></param>
201         /// <param name="first"></param>
202         /// <param name="mid"></param>
203         /// <param name="last"></param>
204         private static void Merger(int[] arry, int first, int mid, int last)
205         {
206             Queue<int> tempV = new Queue<int>();
207             int indexA, indexB;
208             //設定indexA,並掃描subArray1 [first,mid]
209             //設定indexB,並掃描subArray2 [mid,last]
210             indexA = first;
211             indexB = mid;
212             //在沒有比較完兩個子標的情況下,比較 v[indexA]和v[indexB]
213             //將其中小的放到臨時變數tempV中
214             while (indexA < mid && indexB < last)
215             {
216                 if (arry[indexA] < arry[indexB])
217                 {
218                     tempV.Enqueue(arry[indexA]);
219                     indexA++;
220                 }
221                 else
222                 {
223                     tempV.Enqueue(arry[indexB]);
224                     indexB++;
225                 }
226             }
227             //複製沒有比較完子表中的元素
228             while (indexA < mid)
229             {
230                 tempV.Enqueue(arry[indexA]);
231                 indexA++;
232             }
233             while (indexB < last)
234             {
235                 tempV.Enqueue(arry[indexB]);
236                 indexB++;
237             }
238             int index = 0;
239             while (tempV.Count > 0)
240             {
241                 arry[first + index] = tempV.Dequeue();
242                 index++;
243             }
244         }
245 
246         /// <summary>
247         /// 基數排序
248         /// 約定:待排數字中沒有0,如果某桶內數字為0則表示該桶未被使用,輸出時跳過即可
249         /// </summary>
250         /// <param name="arry">待排陣列</param>
251         /// <param name="array_x">桶陣列第一維長度</param>
252         /// <param name="array_y">桶陣列第二維長度</param>
253         public static void RadixSort(this int[] arry, int array_x = 10, int array_y = 100)
254         {
255             /* 最大數字不超過999999999...(array_x個9) */
256             for (int i = 0; i < array_x; i++)
257             {
258                 int[,] bucket = new int[array_x, array_y];
259                 foreach (var item in arry)
260                 {
261                     int temp = (item / (int)Math.Pow(10, i)) % 10;
262                     for (int l = 0; l < array_y; l++)
263                     {
264                         if (bucket[temp, l] == 0)
265                         {
266                             bucket[temp, l] = item;
267                             break;
268                         }
269                     }
270                 }
271                 for (int o = 0, x = 0; x < array_x; x++)
272                 {
273                     for (int y = 0; y < array_y; y++)
274                     {
275                         if (bucket[x, y] == 0) continue;
276                         arry[o++] = bucket[x, y];
277                     }
278                 }
279             }
280 
281         }
282 
283     }

相關推薦

C#排序實現方法

1 /// <summary> 2 /// 排序輔助類 3 /// </summary> 4 public static class SortExtention 5 { 6 /// <summary

C++選擇排序實現

#include <iostream> #include<string> using namespace std; void print(int a[], int n ,int i){ cout<<i <<":"; for(int j

LeetCode Merge K Sorted Lists 問題和解答程式 C++ priority queue實現方法

Merge k Sorted Lists Mergeksorted linked lists and return it as one sorted list. Analyze and describe its complexity. 其實這個問題真沒有什麼“技巧”;

c++堆排序實現(heapsort) (演算法導論)

利用最大堆實現。 最大堆:最大堆性質是除了根結點意外的所有結點 i 都要滿足A[parent[i]] >= A[i] 需要利用到的一個性質:當用陣列表示儲存n個元素的堆時,葉結點的下標分別是n/2, n/2+1, n/2 + 2, ......,n - 1.  (下標

c++堆排序實現

堆排序的時間複雜度是O(nlgn) #include<iostream> using namespace std; int arrs[] = { 23, 65, 12, 3, 8, 76

c實現的各種排序方法

else print switch %d [] code article 選擇 ++ #include <stdio.h> void swap(int *a, int *b); void bubble_sort(int a[], int n); void

經典演算法之歸併排序C實現方法

以前寫過歸併排序的演算法,但是時間過了好久,忘記怎麼寫的了,(也是醉了)。正好複習演算法的時候遇到這個問題,就重新寫了一下,把遇到的一些問題順便記錄一下。 核心就是用兩個子陣列記錄分割後的兩個陣列中的變數, 然後依次比較大小即可。 這裡有個細節需要注意一下,

C++差分隱私的指數機制的一種實現方法

list and span 機制 namespace stdio.h int class ++ #include <iostream> #include<stdio.h> #include<stdlib.h> #include<m

C#利用反射來判斷對象是否包含某個屬性的實現方法

是否 npr nbsp pro bsp str return ram ret 本文實例展示了C#利用反射來判斷對象是否包含某個屬性的實現方法,對於C#程序設計人員來說有一定的學習借鑒價值。 具體實現代碼如下: 1 /// <summary> 2 /// 利

js實現快速排序方法

大小 我們 mage 左右 div () quicksort www for 因為面試面到了這個問題,所以寫一下,加深印象,有兩種方法 第一種是通過兩個for循環,每一次對比相鄰兩個數據的大小,小的排在前面,如果前面的數據比後面的大就交換這兩個數的位置,這個方法就是比較次數

Unix時間戳轉日期時間格式,C#、Java、Python語言實現

[1] oda total 轉換 n) str nbsp -m col 之前有個Q上好友沒事問我,怎麽自己寫Unix時間戳轉日期時間?於是我就順手寫了個C#版本給他!最近想起來,就萌發多寫幾個語言的版本分享,權當練習思路外加熟悉另外兩種語言。 先說轉換步驟 先處理年份

C# 更新Mongodb子文檔的實現方法

target person mod for builder pda log date() upd 參考資源:   1:mongodb3.2系統性學習——3、update()操作   2: C# 操作mongodb子文檔 代碼如下: var mongoString =

C中strstr的實現方法

split pen javadoc sid rst string.h while header 沒有 做題目的時候須要自己實現strstr函數 /*****************************************************

C 雙向鏈表的簡單排序實現

rtb swap 結構 code str 表頭 urn else 重新 今天偶爾看到了C結構體的單項鏈表。 於是重新溫習了下雙向鏈表,重寫了下雙向鏈表的簡單排序實現,當做溫習總結吧。 先定義雙向鏈表 1 struct Student{ 2 int studentI

c# 多態實現_虛方法

write line ons lin nbsp lba clas blog class 實現方法: 虛方法, 抽象類, 接口 1、虛方法   將父類的方法標記為虛方法,使用關鍵字virtual,這個方法可以被子類重新寫一遍。   在父類的方法前面加上一個virtual,在子

C#生成互不相同隨機數的實現方法

adding 定義 是否 point byte 設計 amp 發生器 fff 本文實例講述了C#生成互不相同隨機數的實現方法,在進行C#應用程序設計時非常具有實用價值。本文詳細講述了其功能的實現過程。分享給大家供大家參考之用。具體方法如下: 一般來說,用C#生成足夠隨機的

C#應用BindingSource實現數據同步的方法

som namespace tin 分享 add art creat line erb 本文以實例形式講述了C#應用BindingSource實現數據同步的方法,對C#數據庫程序開發來說具有一定的參考借鑒價值。具體實現方法如下: 下面的代碼示例演示如何使用 Binding

C#檢測座機來電號碼實現來電彈屏的實現方法

廣泛 pre options efault cal ive obj cli == 在我們的程序開發中,有些行業用到座機的來電彈屏,而C#作為微軟的一個重要開發工具,應用廣泛,本代碼實現了C#調用DLL實現來電彈屏(以中盛座機來電顯示盒為例,該盒子穩定可靠,編程簡單)。

C#使用DataSet Datatable更新數據庫的三種實現方法

從數據 數據庫 設計 dddddd 操作註冊表 同時 包含 一個 自動 本文以實例形式講述了使用DataSet Datatable更新數據庫的三種實現方法,包括CommandBuilder 方法、DataAdapter 更新數據源以及使用sql語句更新。分享給大家供大家參

基於私鑰加密公鑰解密的RSA算法C#實現方法

第一個 inter tro 十進制 函數 軟件 產生 ++ 原創 本文實例講述了基於私鑰加密公鑰解密的RSA算法C#實現方法,是一種應用十分廣泛的算法。分享給大家供大家參考之用。具體方法如下: 一、概述 RSA算法是第一個能同時用於加密和數字簽名的算法,也易於理解和操