数据结构学习笔记一：简单排序与查询算法

很悲剧，写的好多东西，到源代码那儿想改个属性的，结果没了一大半，就这样了凑合着吧

选择排序的原理

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;
}
}
}
}

[/code]

冒泡排序的原理：

（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;
}
}

[/code]

两种简单的查找算法：

顺序查找：适合未排序的数列

public int LinearSearch(int[] arr, int elem)
{
for (int i = 0; i <= arr.GetUpperBound(0); i++)
{
if (arr[i] == elem)
return i;
}
return -1;
}

[/code]
二分查找：适合已排好序的

（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;
}
}

[/code]
（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;
}

[/code]
递归与迭代：迭代（一般循环实现）效率更高，递归（调用自己）的层次性更强，让读者更容易理解，但速度不敢恭维。