排序

 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;

int temp;

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.  第一次写博客，感觉版式不是很理想，以后我会尽量做得更好，也会多用博客来记录我的技术心得与生活的点点滴滴，以致于我逝去的青春！望路英雄豪杰前来纰漏，以至于我能够写出更出色的文章！

转载于:https://www.cnblogs.com/Programmer-JZ/p/3764079.html