1.顺序查找:
顺序查找很简单,无非就是找数,既在一串数中查找你想要查找的数,若找到,则返回这个查找数在数列中的位置,反之,则返回-1,表示查找失败!
代码如下:
int Search(int list[], int data)
{
int i = 0;
while (list[i])
{
if (list[i] == data)
return i;
i++;
}
return -1;
}
2.折半查找:
折半查找呢,顾名思义,就是折半!定义一个Left指向数列List的第一个数,再定义一个Right指向数列List的最后一个数,再取Left和Right的二分之一,也就是Middle=(Left+Right)/2,把Middle作为数列的下标,再让查找数data与List[Middle]进行比较,此时:
1.若data>List[Middle],则Left=Middle+1;
2.
若data<List[Middle],则Right=Middle-1;
3.若
data<List[Middle],则查找成功.
折半查找就是每次都进行上述三个步骤,知道Left>Right时,查找停止!因为Left=Right时,此时List[Middle]已是最后的一个数,若还是未找到,则查找停止!
代码如下:
int Search(int List[], int data, int Left, int Right)
{
int Middle;
while (Right >= left)
{
Middle = Right + Left;
if (List[Middle] > data)
Right = Middle - 1;
if (List[Middle] == data)
return Middle;
if (List[Middle] < data)
Left = Middle + 1;
}
return -1;
}
3.插入排序:
插入排序,就是将一个数放在数列中适当的位置,结果数列还是按顺序排列!首先,让一个数先插入到数列中,此时,从数列的第二个(i=1)开始,依次与在它前面的数值比较,只要前面的数值比List[i]大,则挪动位置,直到前面的数值比List[i]小,插入此时List[i]到相应的位置。进行此操作次数为数列长度Length-1;
代码如下;
void InSert_Sort(int List[], int Length)
{
int i, j;
for (i=1; i<Length; i++)
{
temp = List[i];
for (j=i-1; j>=0 && temp<List[j]; j--)
{
List[j+1] = List[j];
}
List[j+1] = temp;
}
}
4.快速排序:
快速排序呢,真是有点乱,不过呢,让我来把它简单化吧!快速排序,就是以第一个数为基数字List[0],再把List[0]依次与数列下标i为1的数开始比较,依次递增i的值,直到这个数比List[0]大,则标记这个数为List[i]。同理,也让List[0]依次与数列下标j为Length-1的数开始比较,然后再依次递减j的值,直到这个数比List[0]小,此时,交换List[I]与List[j]的值,直到i>j时,把List[0]与List[j]的值交换,这个时候,在List[j]左边的数就已经比List[j]小,在List[j]右边的数就已经比List[j]大。
如果只进行上述这种操作,得到结果的数列还是没有全部排好序的,原因是我们没有对数列进行更进一步的排序,所以得到的数列只是粗略的排序不足为奇!为了得到一个完整正确结果,我们需要对数列的左边继续执行上述操作,右边也一样,直到数列中的数列小标i=j时,排序完成!
代码如下:
void qSort(int List[], int Left, int Right)
{
int pivot, i, j;
if (Left < Right)
{
i = Left, j = Right + 1;
pivot = List[Left];
do
{
do {
i++;
}while (List[i] < pivot);
do {
j--;
}while (List[j] > pivot);
if (i < j)
swap(List[i], List[j]);
}while (i < j);
swap(List[Left], List[j]);
qSort(List, Left, j-1);
qSort(List, j+1, Right);
}
}
5.归并排序
此排序按长度Length为1,2,4....2*Length的倍数两两归并,但归并的长度不能超过数列List的长度!
代码如下:
//i表示起始的位置,m表示数列List中i到m之间的个数,n表示数列List中m+1到n之间的个数,Sort表示新的数组
//对传入数列中的数值进行排序
void qSort(int List[], int Sort[], int i, int m, int n)
{
int j = m+1;
int k = i;
while (i<=m && j<=n)
{
if (List[i] <= List[j])
Sort[k++] = List[i++];
if (List[i] >= List[j])
Sort[k++] = List[j++];
}
if (i > m)
for (int t=j; t<=n; t++)
Sort[k++] = List[t];
else
for (int t=i; t<=m; t++)
Sort[k++] = List[t];
}
//按归并的长度对数列进行排序
void Bin_Sort(int List[], int Sort[], int n, int length)
{
int i, j;
for (i=0; i<n-2*length; i+=2*length) //按长度进行排序
qSort(List, Sort, i, i+length-1, i+2*length-1);
if (i+length < n) //用于在进行两两归并时其中有一个存在个数不够时使用
qSort(List, Sort, i, i+length-1, n-1);
else
for (j=i; j<n; j++)
Sort[j] = List[j];
}
//进行按长度归并排序的全部步骤
void All_BinSort(int List[], int Sort[], int n, int length)
{
while (length < n)
{
All_Sort(List, Sort, n, length);
length *= 2;
All_Sort(Sort, List, n, length); //因为上一次调用后数列存放在List中,所以这里再次调用要调换一下!
length *= 2;
}
}
6.堆排序
堆排序分为大堆和小堆,原理是一样,所以这里我就讲一下大堆排序。把数组的下标看成是树的节点下标,这样很容易地解决堆排序问题了!首先,需要对树的每个根节点与其子节点进行比较,如果比其大的,则停止交换;如果比其小的,则把节点跟其子节点进行交换,交换后继续再跟子节点比较,这样一趟下来后,树从上到下基本上已经按照从小到大排好了。接下来从最后一个根节点开始,让其跟子节点比较,如果比其大的,则停止交换;如果比其小的,则把节点跟其子节点进行交换,交换后继续再跟子节点比较,做到结束后,让最后一个节点跟第一个节点交换,再把SUM-1个节点进行排序,然后再把(SUM-1)/2个节点与第一个节点交换,这样一直做下去,直到SUM为0!最后对树按顺序遍历,结果也就正确了!
代码如下:
void qSort(int List[], int nIndex, int size) //nIndex为根节点下标.size为数组大小
{
int max;
while (nIndex*2+1 < size)
{
max = nIndex * 2 + 1;
if (nIndex*2+2 < size)
if (List[max] < List[nIndex*2+2])
max = nIndex*2+2;
if (List[nIndex] > List[max])
break;
else
{
swap(List, nIndex, max);
nIndex = max;
}
}
}
void BeginSort(int List[], int nIndex, int size) //开始对每个节点进行排序
{
int i;
for (i=nIndex; i>=0; i--)
{
qSort(List, i, size);
}
}
void HeapSort(int List[], int size)
{
int i = size - 1;
BeginSort(List, size/2, size);
for (; i>=1; i--)
{
swap(List, 0, i);
qSort(List, 0, i);
}
}
7.希尔排序
希尔排序说白了就是插入排序,原理基本上一样,所以只要插入排序动了,希尔排序自然不攻而破!
代码如下:
void ShellSort(int List[], int size)
{
int i, j;
int gap;
int temp;
for (gap=size/2; gap>0; gap/=2)
for (i=gap; i<size; i++)
{
temp = List[i];
for (j=i-gap; j>=0 && temp<List[j]; j-=gap)
List[j+gap] = List[j];
List[j+gap] = temp;
}
}
8.冒泡排序
冒泡排序是比较相邻的元素。如果第一个比第二个大,就交换他们两个;否则,则不进行交换,此时进行比较的数值是较小的元素,然后这个数值继续与其它数值进行比较,直到剩下最后一个数值为止。这样进行每趟操作后,我们会发现越小的数会越往前靠。针对所有的元素重复以上的步骤,直到剩下最后一个不用进行比较操作。所以冒泡排序比较个数总是比它的总个数少一!
代码如下:
void Bubble_Sort(int List[], int size)
{
int i, j;
int temp;
for (i=0; i<size-1; i++)
for (j=size-1; j>i; j--)
if (List[j] > List[j-1])
{
temp = List[j];
List[j] = List[j-1];
List[j-1] = temp;
}
}
9.选择排序
选择排序工作原理就是首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
代码如下:
void selection_sort(int *list, int list_size) {
int i, j; // 用于循环
int min_index; // 当前最小值
int temp; // 用于交换
// 最后一个元素不用排了, 所以可以 len - 1, 少一次循环
for (i = 0; i < list_size - 1; ++i) {
// 假定当前的元素就是最小的
min_index = i;
// 查找剩下的元素当中最小的
for (j = i; j < list_size; ++j) {
if (list[j] < list[min_index]) {
min_index = j;
}
}
// 如果找到了比当前小的, 就把当前元素与之交换
if (min_index != i) {
temp = list[i];
list[i] = list[min_index];
list[min_index] = temp;
}
}
}
P.S. 第一次写博客,感觉版式不是很理想,以后我会尽量做得更好,也会多用博客来记录我的技术心得与生活的点点滴滴,以致于我逝去的青春!望路英雄豪杰前来纰漏,以至于我能够写出更出色的文章!