数据结构_4（常见代码）

一下是一些常用查找和排序算法的代码（c语言）：

顺序查找

int sq_search(keytype key[], int n, keytype key)
{
    int i;
    for(i=0;i<n;i++)
       if(key[i] == key)   //查找成功
         return i;  //返回关键字在key[]中的下标
    return -1;  //查找失败
}

折半查找

int bin_search(keytype key[], int n, keytype k)
{
    int low = 0, high = n-1, mid;
    while(low<high)
    {
        mid = (low+high) / 2;
        if(key[mid] == k)
          return mid;       //查找成功，返回mid 
        if(k > key[mid])    //在后半序列查找 
          low = mid + 1;
        else                //在前半序列查找 
          high = mid - 1;
    }
    return -1;              //查找失败，返回-1 
} 

直接插入排序

void insertsort(keytype k[], int n)
{
    int i, j;
    keytype tmp;
    for(i=2;i<=n;i++)   //循环n-1次，执行n-1趟插入排序 
    {
        tmp = k[i];     //将k[i]保存在临时变量tmp中 
        j = i-1;
        while(j>0 && tmp<k[j]) //找到tmp的位置插入 
           k[j+1] = k[j--];    //将k[j]后移，再将j-1 
        k[j+1] = tmp;          //将元素tmp插入到指定位置，第i-1趟插入完成 
    }
} 

选择排序

void selectsort(keytype k[], int n)
{
    int i, j, min;
    keytype tmp;
    for(i=1;i<=n-1;i++)
    {
        min = i;
        for(j=i+1;j<=n;j++) //在后n-i+1个元素中找到最小的元素
           if(k[j] < k[min])
              min = j;      //用min记录最小元素的位置 
        if(min != j)        //如果最小的元素不位于后n-i+1个元素的下标 
        {
           tmp = k[min];
           k[min] = k[i];   //元素的交换 
           k[i] = tmp;
        }
    }
} 

冒泡排序（改进后的代码）

void bubblesort(keytype k[], int n)
{
    int i, j, tmp, flag = 1;
    for(i=1;i<=n-1 && flag == 1;i++)
    {   flag = 0;
       for(j=1;j<=n-i;j++)
       {  if(k[j]>k[j+1])
          {
              tmp = k[j+1];
              k[j+1] = k[j];
              k[j] = tmp;
              flag = 1;
          }
       } 
    } 
} 

希尔排序

void shellsort(keyype k[], int n)
{
    int i, j, flag, gap = n;
    keytype tmp;
    while(gap > 1)
    {
        gap = gap/2;  //缩小增量，每次减半 
        do            //子序列运用冒泡排序，当然其他的也行 
        {
            flag = 0;
            for(i=1;i<=n-gap;i++)
            {
                j = i + gap;
                if(k[i]>k[j])
                {
                    tmp = k[i];
                    k[i] = k[j];
                    k[j] = tmp;
                    flag = 1;
                }
            }
        }while(flag != 0)
    }
} 

快速排序

//快速排序
void quicksort(keytype k[], int s, int t)
{
    int i, j;
    if(s<t)
    {
        i = s;
        j = t + 1;
        while(1)
        {
            do i++;
            while(!(k[s]<=k[i] || i==t))
                do j--;
            while(!(k[s]>=k[j] || j==s))
            if(i<j)
              swap(k[i],k[j]);
            else
              break;
        }
        swap(k[s],k[j]);
        quick(k,s,j-1);
        quick(k,j+1,t);
    }
}