一、首先我們先講一下ref與out的區別和使用方法； 1、ref與out的區別： out：需要在使用前聲明變數，分配地址但不能賦值，但是需要在使用中的時候需要初始化（進入方法體中的時候需要先賦值在使用），至於為什麼要在方法體中使用，我個人認為是為了區別ref；（即只出不進） ref：需要在使用前聲明 ...
一、首先我們先講一下ref與out的區別和使用方法；
1、ref與out的區別：
out：需要在使用前聲明變數，分配地址但不能賦值，但是需要在使用中的時候需要初始化（進入方法體中的時候需要先賦值在使用），至於為什麼要在方法體中使用，我個人認為是為了區別ref；（即只出不進）
ref：需要在使用前聲明且初始化，分配地址並且賦值，這樣做可以根據初始化的值帶入，可以根據傳入的值進行一些邏輯判斷；（即有進有出，有頭有尾）
共同點：都需要先聲明變數，且都有回傳值。
2、使用方法：
首先我們先看看兩者使用方法：首先我們先創建兩個方法一個用out一個用ref，回傳一個int值
private static int[] bubbleSort(int[] sources,out int count)
{
int temp;
count = 0;
for (int i = 0; i < sources.Length; i++)
{
for (int j = i + 1; j < sources.Length; j++)
{
if (sources[j] < sources[i])
{
temp = sources[j];
sources[j] = sources[i];
sources[i] = temp;
}
count++;
}
}
return sources;
}
private static int[] bubbleSort2(int[] sources, ref int count)
{
int i, j, temp;
for (j = 0; j < sources.Length; j++)
{
for (i = 0; i < sources.Length - 1; i++)
{
if (sources[i] > sources[i + 1])
{
temp = sources[i];
sources[i] = sources[i + 1];
sources[i + 1] = temp;
}
count++;
}
}
return sources;
}
標黃的就是我們用到的out，ref，在兩個方法體中就可以發現不一樣之處，out方法里的count這個參數進入後就有初始化值，然後在後面才能使用，而下麵用ref的方法體中我們沒有發現count的初始化，就可以直接使用，那麼兩者在調用的區別就在於調用的時候了，下麵就是方法調用的時候：
static void Main(string[] args)
{
int[] array = new[] { 1223, 918, 234, 765, 974, 867, 86786, 145432, 867633, 9999999 }; // 目標數組
int findValue = 145432; // 被查找數
//二分法結果
Console.WriteLine(BinarySearch(array, findValue, 0, array.Length - 1) ? "被查找數存在數組array中" : "被查找數不存在數組array中");
//冒泡排序
int count;
int[] intlist = bubbleSort(array, out count);
for (int i = 0; i < intlist.Length; i++)
{
Console.Write(intlist[i]+" ");
} Console.WriteLine("\t"+"迴圈次數為："+count);
//類似冒泡排序，單迴圈次數較多
int count2 = 0;
int[] intlist2 = bubbleSort2(array, ref count2);
for (int i = 0; i < intlist2.Length; i++)
{
Console.Write(intlist2[i] + " ");
} Console.WriteLine("\t" + "迴圈次數為：" + count2);
Console.ReadKey();
}
先只看有深色背景顏色的地方，因為在之前我悶在方法體中看見out在方法體中已經有初始化動作，而ref沒有，那麼再調用之前ref就需要先初始化，out就不需要初始化！
這裡我們在擴展一下，我們知道return也是可以返回值，那麼return的返回值和上述兩者有什麼區別呢？
首先我們之前說了，out和ref，只要在參數值前面註明out或者ref，那麼咱們的返回值可以實現多個，但是用return的話只能是返回一個唯一值，這是最大的區別！
並且return的返回值是直接不可修改的，但是out和ref是可以修改的！
二、接下來我們就看看最常見的排序演算法
1、（普通排序）首先，我們還是借用上述代碼，
首先我們先創建一個數組，同樣的 調用我們寫好的方法，
/// <summary>
/// 非冒泡排序
/// </summary>
/// <param name="sources">目標數組</param>
/// <param name="count">迴圈次數</param>
/// <returns>升序排列結果</returns>
private static int[] bubbleSort2(int[] sources, ref int count)
{
int i, j, temp;
for (j = 0; j < sources.Length; j++)
{
for (i = 0; i < sources.Length - 1; i++)
{
if (sources[i] < sources[i + 1])
{
temp = sources[i];
sources[i] = sources[i + 1];
sources[i + 1] = temp;
}
count++;
}
}
return sources;
}
此代碼有內外迴圈，外迴圈是增加迴圈次數，內迴圈是則是主迴圈，若當前值sources[i]與下一個值對比，如果滿足條件那麼就將此值記錄下來，這裡面他會將所有的都迴圈一遍，才結束！
2、（冒泡排序）
1 /// <summary>
2 /// 冒泡排序
3 /// </summary>
4 /// <param name="sources">目標數組</param>
5 /// <param name="count">迴圈次數</param>
6 /// <returns>升序排列結果</returns>
7 private static int[] bubbleSort(int[] sources,out int count)
8 {
9 int temp; count = 0;
10 for (int i = 0; i < sources.Length; i++)
11 {
12 for (int j = i + 1; j < sources.Length; j++)
13 {
14 if (sources[j] > sources[i])
15 {
16 temp = sources[j];
17 sources[j] = sources[i];
18 sources[i] = temp;
19 }
20 count++;
21 }
22 }
23 return sources;
24 }
上述代碼我們看出同樣是兩個迴圈，但是不一樣就在於內迴圈中，內迴圈的迴圈次數我們看到了，他是根據外迴圈的次數來相對的，如果外迴圈顯示第一個數據，那麼內迴圈則是顯示第二個數字，所以兩個在結果上是一樣的，但是在迴圈次數上這個（冒泡排序）就比那個快一倍，接下來我們就執行以下這兩個方法，在此同時我們同時在看上述中調用的out和ref的用法也用上了
1 static void Main(string[] args)
2 {
3 int[] array = new[] { 1223, 918, 234, 765, 974, 867, 86786, 145432, 867633, 9999999 }; // 目標數組
4
5 //冒泡排序
6 int count;
7 int[] intlist = bubbleSort(array, out count);
8
9 for (int i = 0; i < intlist.Length; i++)
10 {
11 Console.Write(intlist[i]+" ");
12
13 } Console.WriteLine("\t"+"迴圈次數為："+count);
14
15 //類似冒泡排序，單迴圈次數較多
16 int count2 = 0;
17 int[] intlist2 = bubbleSort2(array, ref count2);
18 for (int i = 0; i < intlist2.Length; i++)
19 {
20 Console.Write(intlist2[i] + " ");
21
22 } Console.WriteLine("\t" + "迴圈次數為：" + count2);
23 Console.ReadKey();
24 }
其運行結果如下
結果我們看到了此方法運行，也通過out與ref傳出了我們需要的迴圈次數的值！
三，接下來我們看看二分法
二分法：通俗理解為在一個大數據中查找需要的值，如果一個人查找的話想對費力，兩個人的話就相對快得多，
我們看下代碼
1 static void Main(string[] args)
2 {
3 int[] array = new[] { 1223, 918, 234, 765, 974, 867, 86786, 145432, 867633, 9999999 }; // 目標數組
4 int findValue = 145432; // 被查找數
5 //二分法結果
6 Console.WriteLine(BinarySearch(array, findValue, 0, array.Length - 1) ? "被查找數存在數組array中" : "被查找數不存在數組array中");
7 }
8
9 /// <summary>
10 /// 二分查找/折半查找（分治思想、遞歸，目標數組必須是有序序列），演算法複雜度為o（log（n）,n代表目標數組長度）
11 /// </summary>
12 /// <param name="sources">目標數組</param>
13 /// <param name="findValue">目標查找數</param>
14 /// <param name="low">區間最小索引</param>
15 /// <param name="high">區間最大索引</param>
16 /// <returns>true:存在，false,不存在</returns>
17 private static bool BinarySearch(int[] sources, int findValue, int low, int high)
18 {
19 // 未找到，終止遞歸
20 if (low > high) return false;
21
22 // 折半查找中間值 索引:(a + b) / 2表示算數平均數，即中點
23 int middleIndex = (low + high) % 2 == 0 ? (low + high) / 2 : (low + high) / 2 + 1;
24
25 if (findValue > sources[middleIndex])
26 {
27 // 大於中間值，在區間[middleIndex + 1, high]遞歸繼續查找
28 return BinarySearch(sources, findValue, middleIndex + 1, high);
29 }
30 if (findValue < sources[middleIndex])
31 {
32 // 小於中間值，在區間[low, middleIndex - 1]遞歸繼續查找
33 return BinarySearch(sources, findValue, low, middleIndex - 1);
34 }
35
36 // findValue 等於 sources[middleIndex],找到，終止遞歸
37 return true;
38 }
這就是通過二分法實現查找方式。
以上僅為隨筆，若有錯誤，或有所指點之地，希望大神們不要吝嗇。謝謝！
