資料結構學習筆記一：簡單排序與查詢演算法

 

 

很悲劇，寫的好多東西，到原始碼那兒想改個屬性的，結果沒了一大半，就這樣了湊合著吧

選擇排序的原理

        public void SelectionSort(int[] arr)
        {
int temp;
int min;
for (int outer = 0; outer <= arr.GetUpperBound(0); outer++)
            { 
                min=outer;
for (int inner = outer + 1; inner <= arr.GetUpperBound(0); inner++)
                {
if (arr[min] > arr[inner])
                    {
                        temp = arr[min];
                        arr[min] = arr[inner];
                        arr[inner] = temp;
                    }
                }
            }
        }
 


冒泡排序的原理：
（1）比較arr[0],arr[1]，如果arr[0]>arr[1]，則交換
（2）比較arr[i-1],arr[i]，如果arr[i-1]>arr[i]，則交換直到i=n-1，這樣最大的一個數就在最右邊a[n-1]中了
（3）重複（1）（2）到n-i
        public void BubbleSort(int[] arr)
        {
int temp;
for (int outer = arr.GetUpperBound(0); outer >= 1; outer--)
            {
for (int inner = 0; inner < outer; inner++)
                { 
if(arr[inner]>arr[inner+1])
                    {
                        temp = arr[inner];
                        arr[inner] = arr[inner + 1];
                        arr[inner + 1] = temp;
                    }
                }
            }
        }
插入排序的原理：與冒泡和選擇排序不同，插入排序主要是移動，打過鬥地主的都知道，首先手上有一張牌準備插入第二張是，要按照大小順序排序，一旦插入，就是一個已排序的序列，難的是該插在哪兒，所以要一個個的比較然後移動到合適位置插入。
        public void InsertionSort(int[] arr)
        {
int temp;
int inner;
for (int outer = 1; outer <= arr.GetUpperBound(0); outer++)
            {
                inner = outer;
                temp = arr[outer];
while (inner > 0 && temp < arr[inner - 1])
                {
                    arr[inner] = arr[inner - 1];
                    inner--;
                }
                arr[inner] = temp;
            }
        }
 

兩種簡單的尋找演算法：
順序尋找：適合未排序的數列
        public int LinearSearch(int[] arr, int elem)
        {
for (int i = 0; i <= arr.GetUpperBound(0); i++)
            {
if (arr[i] == elem)
return i;
            }
return -1;
        }
 
二分尋找：適合已排好序的
（1）遞迴方式
        public int BinarySearch(int[] arr, int elem,int low,int high)
        {
int mid = (low + high) / 2;
if (low > high) return -1;
else
            {
if (arr[mid] > elem)
return  BinarySearch(arr, elem, low, mid - 1);
else if (arr[mid] < elem)
return  BinarySearch(arr, elem, mid + 1, high);
else
return mid;
            }
        }
 
（2）迭代方式
        public int BinarySearch(int[] arr,int elem)
        { 
int low=0;
int high=arr.GetUpperBound(0);
int mid;
while (low <= high)
            { 
                mid=(low+high)/2;
if (arr[mid] == elem)
return mid;
if (arr[mid] > elem)
                    high = mid - 1;
if (arr[mid] < elem)
                    low = mid + 1;
            }
return -1;
        }
 

遞迴與迭代：迭代（一般迴圈實現）效率更高，遞迴（調用自己）的層次性更強，讓讀者更容易理解，但速度不敢恭維。
總結：瞭解遞迴和迭代，基礎排序和尋找演算法，為以後的進階演算法做準備。