标准算法整理III

(一）二分法查找

在有序表中对给定值进行顺序查找和二分查找

int k;//查找次数
f1(float a[], float x)  //顺序查找
{
    int i;
    k=1;//区别
    a[0]=x;
    i=N-1;
    while(a[i]!=x)
    {
        i--;k++;
    }
    return(i);//i=0表示没找到
}
f2(float a[], float x)  //二分查找
{
    int l,m,r,t,flag;
    t=k=0;//区别
    if(x>=a[1]&&x<=a[N-1])
    {
        l=1;
        r=N-1;
        flag=0;
        do{
            m=(l+r)/2;
            if(x<a[m])
                r=m-1;
            else if(x==a[m])
                flag=1;
            else
                l=m+1;
            k++;
        }while(l<=r && flag==0);//关键
        if(flag)
            t=m;
    }
    return (t);
}

（二）二叉排序树

输入字符串，以查找定义二叉排序树，并以先序、中序、后序遍历二叉树

#include <stdio.h>
#include <stdlib.h>

typedef struct ptr TRE;
struct ptr{
    char data;
    TRE *lchild,*rchild;
};//节点定义
TRE *f(char ch,TRE *bt)
{
    if(bt==NULL)
    {
        bt=(TRE*)malloc(sizeof(TRE));//开辟节点空间
        bt->data=ch;
        bt->lchild=NULL;
        bt->rchild=NULL;
    }
    else if(ch<bt->data)
        bt->lchild=f(ch,bt->lchild); //递归
    else
        bt->rchild=f(ch,bt->rchild);
    return bt;
}
int f1(TRE *bt) //先序
{
    if(bt!=NULL)
    {
        printf("%c ",bt->data); //访问根
        f1(bt->lchild); //访问左子树
        f1(bt->rchild); //访问右子树
    }
    return 0;
}
int f2(TRE *bt) //中序,遍历从小到大排列
{
    if(bt!=NULL)
    {
        f2(bt->lchild);
        printf("%c ",bt->data);
        f2(bt->rchild);
    }
    return 0;
}
int f3(TRE *bt) //后序
{
    if(bt!=NULL)
    {
        f3(bt->lchild);
        f3(bt->rchild);
        printf("%c ",bt->data);
    }
    return 0;
}
int main(){
    char ch;
    TRE *tree=NULL;
    printf("ch=?");
    while((ch=getchar())!='\n')
        tree=f(ch,tree);
    printf("preorder:\n");
    f1(tree);
    printf("\ninorder:\n");
    f2(tree);
    printf("\npostorder:\n");
    f3(tree);
    printf("\n");
    return 0;
}

（三）快速排序

基本思想：
1）选择一个基准元素，通常选择第一个元素或者最后一个元素。
2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。（从右到左，再从左到右）
3）此时基准元素在其排好序后的正确位置
4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。（递归）

void quick_sort(int s[],int l,int r)//l=0,r=N-1
{
    if(l < r)
    {
        int i=l,j=r,x=s[l];
        while(i<j)
        {
            while(i<j && s[j]>=x)//从右到左找到第一个小于x的数  
                j--;
            if(i<j)
                s[i++]=s[j];

            while(i<j && s[i]<=x)//从左往右找到第一个大于x的数  
                i++;
            if(i<j)
                s[j--]=s[i]; 

        }

        s[i]=x;//i = j的时候，将x填入中间位置  
        quick_sort(s,l,i-1);//递归调用 
        quick_sort(s,i+1,r);        
    }
}