久久99精品国产麻豆,久久se精品一区二区影院 ,久久人人超碰精品CAOPOREN

hoshelly — Thu, 06 Dec 2012 17:28:00 GMT

讑ֺ�列X={x1,x2,x3......xm}和Y={y1,y2,y3,....yn}�Q�要求最长公共子序列�Q�可以按照下面方式递归计算�Q�：当xm=yn�Ӟ��扑և�Xm-1和Yn-1的最长公共子序列�Q�然后在其尾部加上xm卛_��得到X和Y的最长公共子序列�Q�当xm不等于yn的时候，必须解决两个子问题即扑և�Xm-1和Y的最长公共子序列和Yn-1和X的最长工公共子序列，然后�q�两个里面较长者�ؓX和Y的最长公共子序列�Q?/div>

首先建立子问题的最优值递归关系。用C[i][j]表示Xi和Yj的最长公共子序列的长度。其中，Xi={x1,x2,x3......xi},Yj={y1,y2,y3,....yn}�Q�当i=0或者j=0时空序列是Xi和Yj的最长公共子序列�Q�故因此�Q�C[i][j]=0�Q�即�?/div>

代码如下�Q?/div>

C[i][j]=0�Q�（i=0,j=0)

C[i][j]=c[i-1][j-1]+1,xi=yj

C[i][j]=max(C[i][j-1],C[i-1][j]),i,j>0,xi不等于yj�q?/span>

最长公共子�Ԍ��Longest common substring, ��U�LCS�Q�问题指的是求出�l�定的一�l?/span>

字符串的长度最大的共有的子字符丌Ӏ?nbsp;

举例说明�Q�以下三个字�W�串的LCS��是 cde�Q?nbsp;

abcde

cdef

ccde

现在的情冉|��l�你2个字�W�串�Q�请扑ֈ�他们的LCS

��h��意：字符可以不相邻；

输入

输入�W�一行包含一个整数T�Q�表�C�有T�l�数据；

对于每组数据包含2行，每行包含一个非�I�字�W�串�Q�长度不��过1000个字�W?/span>

输出

对于每组数据输出他们的LCS的长度，保证每组数据存在LCS�Q?/span>

样例输入

abcde

cdef

aaaaaaa

aaabaaa

样例输出

分析�Q?/strong>
讑ֺ�列X={x1,x2,x3......xm}和Y={y1,y2,y3,....yn}�Q�要求最长公共子序列�Q�可以按照下面方式递归计算�Q�：当xm=yn�Ӟ��扑և�Xm-1和Yn-1的最长公共子序列�Q�然后在其尾部加上xm卛_��得到X和Y的最长公共子序列�Q�当xm不等于yn的时候，必须解决两个子问题即扑և�Xm-1和Y的最长公共子序列和Yn-1和X的最长工公共子序列，然后�q�两个里面较长者�ؓX和Y的最长公共子序列�Q?/strong>
首先建立子问题的最优值递归关系。用C[i][j]表示Xi和Yj的最长公共子序列的长度。其中，Xi={x1,x2,x3......xi},Yj={y1,y2,y3,....yn}�Q�当i=0或者j=0时空序列是Xi和Yj的最长公共子序列�Q�故因此�Q�C[i][j]=0�Q�即�?/strong>

C[i][j]=0�Q�（i=0,j=0)
C[i][j]=c[i-1][j-1]+1,xi=yj
C[i][j]=max(C[i][j-1],C[i-1][j]),i,j>0,xi不等于yj

实现代码如下�Q?br />
#include
#include<string.h>
int c[1002][1002]={0};
int main()
{
   int N,m,n,i,j;
   char x[1002],y[1002];
  scanf("%d",&N);
  while(N--)
  {
        scanf("%s",x);
        scanf("%s",y);
        m=strlen(x);
        n=strlen(y);
        for(i=1;i<=m;i++)
           for(j=1;j<=n;j++)
           {
               if(x[i-1]==y[j-1])
               {
                  c[i][j]=c[i-1][j-1]+1;
                 }
              else if(c[i-1][j]>=c[i][j-1])
              {
                   c[i][j]=c[i-1][j];
               }
               else
               {
                   c[i][j]=c[i][j-1];
              }
            }
          printf("%d\n",c[m][n]);
  }
  return 0;
}

参考自�Q?span style="font-size: 12px;">http://yangchuanhuahpu.blog.163.com/blog/static/18631884020125272205862/

hoshelly 2012-12-07 01:28 发表评论

归�ƈ排序��法及其实现代码详解

hoshelly — Sun, 25 Nov 2012 13:23:00 GMT

归�ƈ排序法是��两个（或两个以上）有序表合�q�成一个新的有序表�Q�即把待排序序列分�ؓ若干个子序列�Q�每个子序列是有序的。然后再把有序子序列合�ƈ为整体有序序列�?/div>
例如�Q�有数列{6�Q?02�Q?00�Q?01�Q?8�Q?�Q?}
1. 刚开始的分组如下�Q?/div>
　　i=1 [6 202 ] [ 100 301] [ 8 38] [ 1 ]　比较�ơ数�?��?/div>
2. �W�二�ơ，两两分组合�ƈ
　　i=2 [ 6 100 202 301 ] [ 1 8 38 ]　比较�ơ数�?
3. �W�三�ơ，�l�箋合�ƈ
　　i=3　[ 1 6 8 38 100 202 301 ] 比较�ơ数�?
总计的比较次��Cؓ11��?/div>
归�ƈ排序具体工作原理如下�Q�假讑ֺ�列共有n个元素）�Q?/div>
1. ��序列每盔R��两个数字�q�行归�ƈ操作�Q��Ş成floor(n / 2)个序列，排序后每个序列包含两个元�?/div>
2. ��上�q�序列再�ơ归�qӞ��形成floor(n / 4)个序列，每个序列包含四个元素
3. 重复步骤2�Q�直到所有元素排序完�?/div>
归�ƈ操作的过�E�如下：
1. 甌��I�间�Q��其大��ؓ两个已经排序序列之和�Q�该�I�间用来存放合�ƈ后的序列
2. 讑֮�两个指针�Q�最初位�|�分别�ؓ两个已经排序序列的�v始位�|?/div>
3. 比较两个指针所指向的元素，选择相对��的元素攑օ�到合�q�空��_��q�移动指针到下一位置
4. 重复步骤3直到某一指针辑ֈ�序列��?/div>
5. ��另一序列剩下的所有元素直接复制到合�ƈ序列��?br />
自底向上归�ƈ�Q�如图所�C�：

递归实现代码�Q?br />
#include

using namespace std;

void merge(int*arr, int p, int q, int r)
{
     int n1 = q - p + 1;
     int n2 = r - q;

     int* L = new int[n1];
     int* R = new int[n2];

     for(int i = 0; i < n1; i++)
     {
         L[i] = arr[p + i];
     }
     for(int j = 0; j < n2; j++)
     {
         R[j] = arr[q + j + 1];
     }

     int i = 0;
     int j = 0;
     int k = p;

     while((i < n1) && (j < n2))
     {
         if(L[i] <= R[j])
         {
             arr[k] = L[i];
             i++;
         }
         else
         {
             arr[k] = R[j];
             j++;
         }
         k++;
     }

     if (i < n1)
     {
         for(; i < n1; i++, k++)
         {
             arr[k] = L[i];
         }
     }
     if (j < n2)
     {
         for(; j < n2; j++, k++)
         {
             arr[k] = R[j];
         }
     }
}

void mergesort(int* arr, int p, int r)
{
     int q = 0;
     if(p < r)
     {
         q = (p + r) / 2;
         mergesort(arr, p, q);
         mergesort(arr, q + 1, r);
         merge(arr, p, q, r);
     }
}

int main()
{
     int a[] = {5, 2, 4, 7, 1, 3, 2, 6};
     mergesort(a, 0, 7);
     for(int i = 0; i < 8; i++)
     {
         cout << a[i] << " ";
     }
     cout << endl;
     return 0;
}

非递归代码实现�Q?br />
/**
  * merge_sort: 非递归实现 --�q�代
  * 非递归思想: ��数�l�中的相��d��素两两配寏V��用merge函数��他们排序，
  * 构成n/2�l�长度�ؓ2的排序好的子数组�D�，然后再将他们排序成长度�ؓ4的子数组�D�，
  * 如此�l�箋下去�Q�直��x��个数�l�排好序�?br /> **/

#include
#include

// merge_sort(): 非递归实现-自底向上
// ��原数组划分为left[minmax] �?nbsp;right[minmax]两部�?/span>
void merge_sort(int *list, int length)
{
     int i, left_min, left_max, right_min, right_max, next;
     int *tmp = (int*)malloc(sizeof(int) * length);

     if (tmp == NULL)
     {
         fputs("Error: out of memory\n", stderr);
         abort();
     }

     for (i = 1; i < length; i *= 2) // i为步长，1,2,4,8……
     {
         for (left_min = 0; left_min < length - i; left_min = right_max)
         {
             right_min = left_max = left_min + i; //right_min取left_max的��|��以下要用到left_max的值才不会改变left_max原先�?/span>
             right_max = left_max + i;

             if (right_max > length) //如果right_max��出了数�l�长度，则right_max�{�于数组长度
                 right_max = length;

             next = 0;
             while (left_min < left_max && right_min < right_max) //tmp[next]存储子数�l�中的最��?/span>
                 tmp[next++] = list[left_min] > list[right_min] ? list[right_min++] : list[left_min++];

             while (left_min < left_max)  //如果left_min��于left_max�Q�则��最��值原��不动地赋给list[--right_min]�Q�right_min 要先�?
                 list[--right_min] = list[--left_max];

             while (next > 0) //��tmp[next]存储的最��值放入list[--right_min]�?/span>
                 list[--right_min] = tmp[--next];
         }
         if(i == 1) //打印�W�一�ơ归�q�后的数字排�?/span>
         {
             for(int j=0;j               printf("%d ",list[j]);
             printf("\n");
         }
     }

     free(tmp);

}

int main()
{
     int a[1000],t,i;
     scanf("%d",&t);
     for(i=0;i     {
         scanf("%d",&a[i]);
     }
     merge_sort(a, t);

     // print array
     for (i = 0; i < t; i++)
         printf("%d ", a[i]);

     return 0;
}

hoshelly 2012-11-25 21:23 发表评论

动态规划解�?1背包问题

hoshelly — Fri, 23 Nov 2012 16:41:00 GMT
动态规划解�?1背包问题�Q?br />代码

#include
int c[10][100];/*对应每种情况的最大�h�?/span>*/
int w[10],p[10];
int knapsack(int m,int n)
{
int i,j,x[10]; //w为物品重量，p��Z�h�?/span>
for(i=1;i
        scanf("\n%d%d",&w[i],&p[i]);
for(i=0;i<10;i++)
      for(j=0;j<100;j++)
           c[i][j]=0;/*初始化数�l?/span>*/
for(i=1;i
      for(j=1;j
           {
            if(w[i]<=j) /*如果当前物品的重量小于背包所能承载的重量*/
                     {
                      if(p[i]+c[i-1][j-w[i]]>c[i-1][j])

                           /*如果本物品的价值加上背包剩下的�I�间能放的物品的价�?/span>*/

                         /*大于上一�ơ选择的最��x��案则更新c[i][j]*/
                            c[i][j]=p[i]+c[i-1][j-w[i]];
                            else
                            c[i][j]=c[i-1][j];
                     }
              else c[i][j]=c[i-1][j];
            }
            printf("\n");

    int contain = m;
    for(int i=n;i>0;--i)
    {
        if(c[i][contain] == c[i-1][contain])//未放入第i个物品，contain表示当前背包的承受重�?/span>
           x[i-1] = 0;  //考虑�Q�f[i][j] = max{ f[i-1][j] �?nbsp;f[i-1][j - w[i]] + v[i] }, if ( f[i][j] == f[i-1][j] )
        else           //则说明物品i未放入；否则物品i 攑օ�了背包中�Q�最大承重量也相应减去w[i]
        {
         x[i-1] = 1;
         contain -= w[i]; // 放上了第i个物品，当前背包的重量要减去相应的物品i的重量，回溯
        }
    }
       for(i=0;i
    {
        printf("%d ",x[i]); //1表示攑օ��Q?表示未放�?/span>
    }
printf("\n");
return(c[n][m]);

}

int main()
{
    int m,n,i,j;
    scanf("%d %d",&m,&n);
    printf("Input the weight and value:\n");
    printf("%d\n",knapsack(m,n));
    return 0;
}

//��试数据�Q? 4
//2 12
//1 10
//3 20
//2 15
//�l�果�Q? 1 0 1  最大�h��|��37

hoshelly 2012-11-24 00:41 发表评论

二叉树之数组存储

hoshelly — Tue, 16 Oct 2012 15:47:00 GMT

二叉树可以采用数�l�的�Ҏ��q�行存储�Q�把数组中的数据依次自上而下,自左臛_��存储��C��叉树�l�点中，一般二叉树与完全二叉树�Ҏ��Q�比完全二叉树缺��的�l�点��在数组中用0来表�C?/span>

�l�点存储的数据均为非负整�?/span>

Input

�W�一行输入一个整数t�Q�表�C�有t个二叉树

�W�二行�v�Q�每行输入一个数�l�，先输入数�l�长度，再输入数�l�内数据�Q�每个数据之间用�I�格隔开�Q�输入的数据都是非负整数

�q�箋输入t�?/span>

Output

每行输出一个示例的先序遍历�l�果�Q�每个结点之间用�I�格隔开

Sample Input

3
3 1 2 3
5 1 2 3 0 4
13 1 2 3 4 0 5 6 7 8 0 0 9 10
Sample Output

1 2 3
1 2 4 3
1 2 4 7 8 3 5 9 10 6

分析�Q?/span>�q�道题的关键在于�Q�设定数�l�位�|�从1开始编��P��那么位置为i的结点，它的左孩子在数组的位�|�是2i�Q�右孩子在数�l�的位置�?i+1

�q�道题的隄��在把树徏立�v来，其他都容易�?/span>

代码�Q?/span>

#include
using namespace std;

class BiTreeNode
{

private:

BiTreeNode  *leftChild;      //左子树指�?/span>

BiTreeNode  *rightChild;      //叛_��树指�?/span>

public:

int  data;           //数据�?br />

//构造函数和析构函数

BiTreeNode():leftChild(NULL), rightChild(NULL){}

BiTreeNode(int  item, BiTreeNode  *left = NULL,

    BiTreeNode  *right = NULL):

    data(item), leftChild(left), rightChild(right){}

~BiTreeNode(){}

BiTreeNode  * &Left(void) //注意�q�回值类型�ؓ指针的引用类�?/span>

  {return leftChild;}

BiTreeNode  * &Right(void) //注意�q�回值类型�ؓ指针的引用类�?/span>

  {return rightChild;}

};

class BiTree

{

private:

BiTreeNode  *root;       //根结�Ҏ��?/span>

    int i,len; //len是树�l�点的数�?/span>

void Destroy(BiTreeNode  * &t);

void PreOrder(BiTreeNode  * &t);

void  CreateBiTree(BiTreeNode * &T,const int arrTree[],int pos);

public:

//构造函数和析构函数

BiTree(void):root(NULL),i(0){};     //构造函�?/span>

~BiTree(void){};        //析构函数

//构造二叉树

   void MakeTree(const int arrTree[],int num); //构造二叉树�Q�利用先序遍历结果徏�?/span>

   void Destroy(void);        //销毁二叉树

void PreOrder();  //前序遍历

};

//2、定义销毁函�?/span>

void BiTree ::Destroy(void)       //销毁二叉树�Q�公有函�?/span>

{

Destroy(root);

}

void BiTree ::Destroy(BiTreeNode  * &t)

//销毁二叉树�Q�私有函��C��共有函数调用

{

if(t != NULL && t->Left() != NULL)

  Destroy(t->Left());

if(t != NULL && t->Right() != NULL)

  Destroy(t->Right());

if(t != NULL)

{
  delete t;
}

}

//3、定义徏树函�?/span>

void BiTree::MakeTree(const int arrTree[],int num)

//构造二叉树�Q�利用先序遍历结果徏树，公有函数

{

   i=0;
   len = num;

   CreateBiTree(root,arrTree,1);//数组位置�?开�?/span>

}

void BiTree::CreateBiTree(BiTreeNode * &T, const int arrTree[],int pos)   //递归建树�U�有函数

{

int ch;

ch=arrTree[pos];

if (ch == 0 || pos > len) T = NULL;

else

{

  T=new BiTreeNode();

  T->data = ch;              // 生成根结�?/span>
  i++;
  if(i>len) return;

  CreateBiTree(T->Left(), arrTree,2*pos);   // 构造左子树

  CreateBiTree(T->Right(), arrTree,2*pos+1);   // 构造右子树

   }

}

//4、定义先序遍历函�?/span>

void BiTree::PreOrder()

//前序遍历讉K��二叉树，公有函数

{

PreOrder(root);

}

void BiTree::PreOrder(BiTreeNode* &t)

//前序遍历讉K��二叉树，�U�有函数t

{

  if(t!=NULL)//若二叉树�l�点不�ؓ�I�，执行如下操作�Q?/span>
  {
      cout<data<<" ";//1、输出当前结点的数据�Q�表�C��l�点被访问了

      PreOrder(t->Left());//2、先序遍历该�l�点的左孩子

      PreOrder(t->Right());//3、先序遍历该�l�点的右孩子
  }

}

int main()
{
    int m,i,j,k;
    int *arrTree;
    BiTree myTree;
    cin>>m;
    for(i=0;i    {
        arrTree = new int[800];
        cin>>k;
        for(j=1;j<=k;j++)
            cin>>arrTree[j];
        myTree.MakeTree(arrTree,k);
        myTree.PreOrder();
        cout<
        delete []arrTree;
        myTree.Destroy();
    }
    return 0;
}

hoshelly 2012-10-16 23:47 发表评论

前缀表达式求值的递归�E�序

hoshelly — Sat, 06 Oct 2012 02:49:00 GMT

#include
#include<string>
using namespace std;
char a[100];
int i;
int eval()
{
    int x=0;
    while(a[i] == ' ') i++;
    if(a[i] == '+')
    {
        i++;
        return eval()+eval();
    }
    if(a[i] == '*')
    {
        i++;
        return eval()*eval();
    }
    while((a[i] >= '0')&&(a[i]<= '9'))
       x = 10*x +a[i++]-'0';
    return x;
}
int main()
{
    gets(a);
    cout<< eval()<    return 0;
}

hoshelly 2012-10-06 10:49 发表评论

一元多��式相加实现

hoshelly — Sun, 23 Sep 2012 07:48:00 GMT

2.3x4+3.2x3+2x2+1.2x�?.6x5-2.3x4+3.4x3
相加�l�果为：5.6x5+6.6x3 +2x2+1.2x
首先考虑存储�l�构�Q�多��式中的每一��包�?#8220;�p�L��”�?#8220;指数”两项�Q�且相加�q�算可能会改变系数和指数�Q�故应采用链式存储结构。在一个单链表�l�点中，存储多项式一��的�p�L��和指数。其�ơ，考虑多项式的�q�算规则�Q�对于两个一元多��式中所有指数相同的��，对应�p�L��相加�Q�若和不�?�Q�则构成“和多��式”中的一��；对于两个一元多��式中所有指��C��同的��，则分别复抄到“和多��式”中去�?/span>

#include
using  namespace  std;

    typedef struct{
    float  coef;   //�p�L��
    int expn;        //指数
}DataType;

struct Node;
typedef struct Node *PNode;
struct Node{
    DataType info;
    PNode link;
};
typedef  struct  Node *LinkList;

typedef  LinkList  polynomial;    //带头�l�点的单链表表示多项�?/span>

int cmp(DataType a,DataType b){
    int flag;
    if(a.expn    else if(a.expn==b.expn)    flag=0;
    else flag=1;
    return flag;
}

//建立多项式单链表
void CreatPolyn(polynomial &P,int m){    //m为多��式��Ҏ��
    polynomial r,s;
    P=new struct Node;
    r=P;
    for(int i=0;i        s=new struct Node;
        cout<<"输入�p�L��和指敎ͼ�";
        cin>>s->info.coef>>s->info.expn;
        r->link=s;
        r=s;
}
r->link=NULL;
}

//多项式相加得到新的多��式
polynomial AddPolyn(polynomial &pa,polynomial &pb){
    polynomial newp,p,q,s,r;
    float sum;
    p=pa->link;
    q=pb->link;
    newp=new struct Node;
    r=newp;
    while(p&&q){
        switch(cmp(p->info,q->info)){    //比较两个多项式的指数
        case -1:        //多项式pa当前�l�点的指数值小
            s=new struct Node;
            s->info.coef=q->info.coef;
            s->info.expn=q->info.expn;
            r->link=s;
            r=s;
            q=q->link;
            break;
        case 0:        //两个多项式指数值相�{?/span>
            sum=p->info.coef+q->info.coef;
            if (sum!=0.0){
                s=new struct Node;
                s->info.coef=sum;
                s->info.expn=p->info.expn;
                r->link=s;
                r=s;
            }
            p=p->link;
            q=q->link;
            break;
        case 1:        //多项式pb当前�l�点的指数值小
            s=new struct Node;
            s->info.coef=p->info.coef;
            s->info.expn=p->info.expn;
            r->link=s;
            r=s;
            p=p->link;
            break;
        }//switch
    }//while

//链接pa剩余�l�点
while(p){
    s=new struct Node;
    s->info.coef=p->info.coef;
    s->info.expn=p->info.expn;
    r->link=s;
    r=s;
    p=p->link;
}
//链接pb剩余�l�点
while(q){
    s=new struct Node;
    s->info.coef=q->info.coef;
    s->info.expn=q->info.expn;
    r->link=s;
    r=s;
    q=q->link;
}
r->link=NULL;
return newp;
}
//输出多项式单链表
void PrintPolyn(polynomial p){
    polynomial s;
    s=p->link;
    while(s){
    //输出�p�L��和指�?/span>
    cout<info.coef<<"("<info.expn<<")";
    s=s->link;
}
cout<}
    void main(){
    int m,n;
    polynomial p,q;
    cout<<"误��入多��式pa的项敎ͼ�";
    cin>>m;
    CreatPolyn(p,m);
    cout<<"误��入多��式pb的项敎ͼ�";
    cin>>n;
    CreatPolyn(q,n);
    PrintPolyn(p);
    PrintPolyn(q);
    PrintPolyn(AddPolyn(p,q));
}

hoshelly 2012-09-23 15:48 发表评论

hoshelly — Tue, 18 Sep 2012 15:12:00 GMT
卡片游戏

桌上有一叠牌�Q�从�W�一张牌开始从上往下依�ơ编�?~n。当臛_��q�剩两张牌时�q�行如下操作�Q�把�W�一张牌扔掉�Q�然后把新的�W�一张牌攑ֈ�整叠牌的最后。输入n�Q�输出每�ơ扔掉的牌，以及最后剩下的牌�?br />
样例输入�Q?
样例输出�Q? 3 5 7 4 2 6

代码如下�Q?br />
#include
#include
using namespace std;
queue<int> q; //声明队列
int main()
{
    int n;
    cin>>n;
    for(int i=0;i    while(!q.empty())
    {
        cout<        q.pop();
        if(!q.empty()) //此处需要判断此旉��列是否�ؓ�I?br />        {
           q.push(q.front());
           q.pop();
        }
    }
    cout<    return 0;
}

hoshelly 2012-09-18 23:12 发表评论

hoshelly — Mon, 17 Sep 2012 07:41:00 GMT

#include
#include
typedef struct STACKnode* link; //堆栈的链表实�?/span>
struct STACKnode
{
    int item;
    link next;
};
static link head;
link NEW(int item,link next)
{
    link x=(link)malloc(sizeof(STACKnode));
    x->item = item; //��新建立的结�Ҏ��加到链表�?/span>
    x->next = next; //此时head指向新徏立的�l�点�Q�此�l�点的next�l�点�Q�即为原先是头结点的�l�点(旧头�l�点)
    return x;  //函数�q�回新徏立的头结点，此结�Ҏ��L��位于栈顶
}

void STACKinit()
{
    head = NULL;
}
int STACKempty()  //�|�空�?/span>
{
    return head == NULL;
}
void STACKpush(int item)
{
    head = NEW(item,head);
}
int STACKpop()
{
    int item = head->item; //��头�l�点上的值取�?/span>
    link t = head->next;
    free(head); //释放此头�l�点内存
    head = t; //head指向新的头结点t
    return item; //�q�回旧的头结点的�?/span>
}

int main()
{
    int i;
    STACKinit();
    for(i=1;i<=10;i++)
        STACKpush(i);
    for(i=1;i<=10;i++)
        printf("%d ",STACKpop());
    printf("\n");
    return 0;
}

hoshelly 2012-09-17 15:41 发表评论

中缀--后缀转换

hoshelly — Mon, 17 Sep 2012 05:06:00 GMT

#include
#include<string.h>
#include
#define M 1000
static int N; //N栈的大小
static int *s;
void STACKinit(int maxN) //建立一个动态数�l�s�Q�相当于建立�q�初始化�?/span>
{
    s = (int *)malloc(maxN*sizeof(int));
    N=0;
}
int STACKempty()
{
    return N==0;
}
void STACKpush(int item)
{
    s[N++] = item;
}
int STACKpop()
{
    return s[--N];
}

int main()  //�E�序作用�Q�将中缀表达式�{为后�~�表达�?/span>
{
    char a[M];
    gets(a); //输入中缀表达�?/span>
    STACKinit(N);
    int i,len=strlen(a);
    for(i=0;i    {
        if(a[i] == ')')
            printf("%c ",STACKpop()); //遇到��x��号弹出栈��的�q�算�W?/span>
        if((a[i] == '+') || (a[i] == '*'))
            STACKpush(a[i]);             //��运��符压入�?/span>
        if((a[i] == '-') || (a[i] =='/'))
            STACKpush(a[i]);
        if((a[i] >= '0') && (a[i] <= '9')) //遇到数字则输�?/span>
            printf("%c ",a[i]);
    }
    return 0;
}

�C�Z��Q?br />

hoshelly 2012-09-17 13:06 发表评论

hoshelly — Mon, 17 Sep 2012 04:03:00 GMT

#include
#include<string.h>
#include
#define M 1000
static int N; //N栈的大小
static int *s;
void STACKinit(int maxN) //建立一个动态数�l�s�Q�相当于建立�q�初始化�?/span>
{
    s = (int *)malloc(maxN*sizeof(int));
    N=0;
}
int STACKempty()
{
    return N==0;
}
void STACKpush(int item)
{
    s[N++] = item;
}
int STACKpop()
{
    return s[--N];
}

int main()
{
    char a[M];
    gets(a); //输入后缀表达式，每个整数之后臛_��要有一个空�?/span>
    int i,len,ok;
    char k[15]={' ','0','1','2','3','4','5','6','7','8','9','+','-','/','*'};
    len=strlen(a);
    while(1)  //��查输入字�W�串的合法性（仅限于检查输入是否�ؓ包含数字�? - * / �?nbsp;' '的字�W�串�Q?/span>
    {
       ok=0;
       for(i=0;i      {
         for(int j=0;j<15;j++)
         {
            if(a[i] == k[j])
            {
                ok=1;
            }
         }
         if(!ok)
         {
             printf("Input error! please input again:\n");
             break;
         }
       }
       if(!ok)
       {
          gets(a);
          len=strlen(a);
       }
       else
           break;
    }

    STACKinit(len); //初始化N=0
    for(i=0;i    {
        if(a[i] == '+')
            STACKpush(STACKpop()+STACKpop());
        if(a[i] == '*')
            STACKpush(STACKpop()*STACKpop());
        if(a[i] == '-')
        {
            b = STACKpop();
            c = STACKpop();
            STACKpush(c-b);
        }

        if(a[i] == '/')
        {
            b = STACKpop();
            c = STACKpop();
            STACKpush(c/b);
        }


        if((a[i] >= '0') && (a[i] <= '9')) //如果遇到数字�Q�则先压�?�q�栈
            STACKpush(0);
        while((a[i] >='0') && (a[i] <='9'))
            STACKpush(10*STACKpop()+(a[i++]-'0'));//再将“字符数字”转换为数�?/span>
    }

    printf("%d \n",STACKpop());
    return 0;
}

�C�Z��Q?br />

hoshelly 2012-09-17 12:03 发表评论

二分搜烦��法

hoshelly — Sat, 15 Sep 2012 16:05:00 GMT
二分搜烦��法的��用前提条件是表中的数已经是有序的�Q�如果还没排好序�Q�则不能用二分搜索算法�?br />

int search(int a[],int v,int l,int r) //在数�l�a[]内查找v�Q�l为左下标�Q�r为右下标
{
    while (r>=l)
    {
        int m=(l+r)/2; //每次取数�l�的一�?此处要加1
        if(v == a[m]) //如果查找到v�Q�则�q�回下标m
            return m;
        if(v < a[m])  //如果v��于此时的数�Q�则右下标变成r=m-1�Q�去掉数�l�中一半的敎ͼ�反之亦然
            r=m-1;
        else
            l=m+1;
    }
    return -1;
}

hoshelly 2012-09-16 00:05 发表评论

hoshelly — Tue, 21 Aug 2012 14:38:00 GMT

#include
#include
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int ElemType;
typedef int Status;
typedef struct {
    ElemType *elem; //存储�I�间基址
    int length; //当前的线性表长度
    int listsize; //当前分配的存储容�?/span>
}SqList;

//初始化线性表
Status InitList_Sq(SqList *L) //用线性表的指针操�?/span>
{
    (*L).elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if(!(*L).elem) exit(OVERFLOW);
    (*L).length=0;
    (*L).listsize=LIST_INIT_SIZE;
    return OK;
}
int ListLength(SqList L)
{
    return L.length;
}

Status GetElem(SqList L,int i,ElemType *e)
{
    if(i<1 || i>L.length)
        exit(ERROR);
    *e=*(L.elem+i-1);
    return OK;
}

Status ListInsert(SqList *L,int i,ElemType e)
{
    ElemType *newbase,*p,*q;
    if(i<1 || i>(*L).length+1)
        return ERROR;
    if((*L).length >= (*L).listsize)
    {
        newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
        if(!newbase) exit(OVERFLOW);
        (*L).elem=newbase;
        (*L).listsize +=LISTINCREMENT;
    }
    q=(*L).elem+i-1; //插入位置
    for(p=(*L).elem+(*L).length-1;p>=q;--p)
        *(p+1)=*p;
    *q=e;
    ++(*L).length;
    return OK;
}

int LocateElem(SqList L,ElemType e)
{
    int i;
    for(i=0;i    {
        if(*(L.elem+i) == e)
            break;
    }
    if(i>=L.length)
        return 0;
    return i+1;
}

Status Visit(ElemType *c)
{
    printf("%d ",*c);
    return OK;
}

Status ListTraverse(SqList L)
{
    int i;
    for(i=0;i        Visit(L.elem+i);
    printf("\n");
    return OK;
}

void Union(SqList *La,SqList Lb) //求La和Lb中元素的集合La�Q�即把Lb中与La不相同的元素取出来插入La�?/span>
{
    ElemType La_len,Lb_len;
    int i,e;
    La_len=ListLength(*La);
    Lb_len=ListLength(Lb);
    for(i=1;i<=Lb_len;i++)
    {
        GetElem(Lb,i,&e);
        if(!LocateElem(*La,e))
            ListInsert(La,++La_len,e);
    }
}//Union
int main()
{
    SqList La,Lb;
    int j,a[4]={3,5,8,11},b[7]={2,6,8,9,11,15,20};
    InitList_Sq(&La);
    for(j=1;j<=4;j++)
        ListInsert(&La,j,a[j-1]);
    printf("print La: \n");
    ListTraverse(La);

    InitList_Sq(&Lb);
    for(j=1;j<=7;j++)
        ListInsert(&Lb,j,b[j-1]);
    printf("print Lb: \n");
    ListTraverse(Lb);

    Union(&La,Lb);

    printf("print La: \n");
    ListTraverse(La);

    return 0;
}

hoshelly 2012-08-21 22:38 发表评论

归�ƈ两个�U�性表得到新的�U�性表

hoshelly — Tue, 21 Aug 2012 13:51:00 GMT

#include
#include
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int ElemType;
typedef int Status;
typedef struct {
    ElemType *elem; //存储�I�间基址
    int length; //当前的线性表长度
    int listsize; //当前分配的存储容�?/span>
}SqList;

//初始化线性表
Status InitList_Sq(SqList *L) //用线性表的指针操�?/span>
{
    (*L).elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if(!(*L).elem) exit(OVERFLOW);
    (*L).length=0;
    (*L).listsize=LIST_INIT_SIZE;
    return OK;
}
int ListLength(SqList L)
{
    return L.length;
}

Status GetElem(SqList L,int i,ElemType *e)
{
    if(i<1 || i>L.length)
        exit(ERROR);
    *e=*(L.elem+i-1);
    return OK;
}

Status ListInsert(SqList *L,int i,ElemType e)
{
    ElemType *newbase,*p,*q;
    if(i<1 || i>(*L).length+1)
        return ERROR;
    if((*L).length >= (*L).listsize)
    {
        newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
        if(!newbase) exit(OVERFLOW);
        (*L).elem=newbase;
        (*L).listsize +=LISTINCREMENT;
    }
    q=(*L).elem+i-1; //插入位置
    for(p=(*L).elem+(*L).length-1;p>=q;--p)
        *(p+1)=*p;
    *q=e;
    ++(*L).length;
    return OK;
}

Status Visit(ElemType *c)
{
    printf("%d ",*c);
    return OK;
}

Status ListTraverse(SqList L)
{
    int i;
    for(i=0;i        Visit(L.elem+i);
    printf("\n");
    return OK;
}

void MergeList(SqList La,SqList Lb,SqList *Lc) //归�ƈ�U�性表La和Lb得到新的�U�性表Lc,Lc的数据元素安�|�递减排列
{
    int i=1,j=1,k=0;
    int La_len,Lb_len;
    ElemType ai,bj;
    InitList_Sq(Lc);
    La_len=ListLength(La);
    Lb_len=ListLength(Lb);
    while((i<=La_len) && (j<=Lb_len)) //如果表La和表Lb都非�I?/span>
    {
        GetElem(La,i,&ai);
        GetElem(Lb,j,&bj);
        if(ai<=bj)
        {
            ListInsert(Lc,++k,ai); ++i;
        }
        else
        {
            ListInsert(Lc,++k,bj); ++j;
        }
    }

    while(i<=La_len)  //如果只有La非空
    {
        GetElem(La,i++,&ai);
        ListInsert(Lc,++k,ai);
    }

    while(j<=Lb_len)
    {
        GetElem(Lb,j++,&bj);
        ListInsert(Lc,++k,bj);
    }
}
int main()
{
    SqList La,Lb,Lc;
    int j,a[4]={3,5,8,11},b[7]={2,6,8,9,11,15,20};
    InitList_Sq(&La);
    for(j=1;j<=4;j++)
        ListInsert(&La,j,a[j-1]);
    printf("print La: \n");
    ListTraverse(La);

    InitList_Sq(&Lb);
    for(j=1;j<=7;j++)
        ListInsert(&Lb,j,b[j-1]);
    printf("print Lb: \n");
    ListTraverse(Lb);

    MergeList(La,Lb,&Lc);

    printf("print Lc: \n");
    ListTraverse(Lc);

    return 0;
}

hoshelly 2012-08-21 21:51 发表评论

�U�性表基本操作

hoshelly — Tue, 21 Aug 2012 08:25:00 GMT

#include
#include
#include
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int ElemType;
typedef int Status;
typedef struct {
    ElemType *elem; //存储�I�间基址
    int length; //当前的线性表长度
    int listsize; //当前分配的存储容�?/span>
}SqList;

//初始化线性表
Status InitList_Sq(SqList *L) //用线性表的指针操�?/span>
{
    (*L).elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if(!(*L).elem) exit(OVERFLOW);
    (*L).length=0;
    (*L).listsize=LIST_INIT_SIZE;
    return OK;
}
int ListLength(SqList L)
{
    return L.length;
}

Status ListEmpty(SqList L)
{
    if(L.length == 0)
        return OK;
    else
        return ERROR;
}

Status ClearList(SqList *L)
{
    (*L).length=0;
    return OK;
}

Status DestroyList(SqList *L)
{
    free((*L).elem);
    (*L).elem=NULL;
    (*L).length=0;
    (*L).listsize=0;
    return OK;
}

Status GetElem(SqList L,int i,ElemType *e)
{
    if(i<1 || i>L.length)
        exit(ERROR);
    *e=*(L.elem+i-1);
    return OK;
}

Status ListInsert(SqList *L,int i,ElemType e)
{
    ElemType *newbase,*p,*q;
    if(i<1 || i>(*L).length+1)
        return ERROR;
    if((*L).length >= (*L).listsize)
    {
        newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
        if(!newbase) exit(OVERFLOW);
        (*L).elem=newbase;
        (*L).listsize +=LISTINCREMENT;
    }
    q=(*L).elem+i-1; //插入位置
    for(p=(*L).elem+(*L).length-1;p>=q;--p)
        *(p+1)=*p;
    *q=e;
    ++(*L).length;
    return OK;
}

Status Visit(ElemType *c)
{
    printf("%d ",*c);
    return OK;
}

Status ListTraverse(SqList L)
{
    int i;
    for(i=0;i        Visit(L.elem+i);
    printf("\n");
    return OK;
}

int LocateElem(SqList L,ElemType e)
{
    int i;
    for(i=0;i    {
        if(*(L.elem+i) == e)
            break;
    }
    if(i>=L.length)
        return 0;
    return i+1;
}

Status ListDelete(SqList *L,int i,ElemType *e)
{
    int k;
    if(L->length == 0)
        return ERROR;
    if(i<1 || i>=L->length)
        return ERROR;
    *e=*(L->elem+i-1);
    if(ilength)
    {
        for(k=i;klength;k++)
            *(L->elem+k-1)=*(L->elem+k);
    }
    L->length--;
    return OK;
}

int main()
{
    int i,e;
    SqList mylist;
    int m = InitList_Sq(&mylist);
    if(m)
    {
        printf("�U�性表创徏成功!\n");
        printf("当前表长: %d \n",ListLength(mylist));
    }
    else
        printf("�U�性表创徏��p�|.");
    for(i=1;i<=10;i++)
        ListInsert(&mylist,i,i);
    ListTraverse(mylist);
    printf("当前表长�Q?d \n",ListLength(mylist));
    GetElem(mylist,5,&e);
    printf("�W?个元素�ؓ�Q?d\n",e);
    ListDelete(&mylist,4,&e);
    printf("删除�W?个元素后�Q?);
    ListTraverse(mylist);
    printf("当前表长�Q?d \n",ListLength(mylist));
    i=ClearList(&mylist);
    printf("清空�U�性表后：表长�?nbsp;%d\n",mylist.length);
    i=ListEmpty(mylist);
    printf("表是否�ؓ�I�：%d (1:�I?nbsp;0�Q�否)\n",i);

    return 0;
}

hoshelly 2012-08-21 16:25 发表评论

hoshelly — Sun, 19 Aug 2012 12:37:00 GMT

#include
#include
typedef struct node *link;
struct node
{ int v; link next; };
link NEW(int v, link next)
{
    link x = (link)malloc(sizeof(node));
    x->v = v; x->next = next;
    return x;
}

int main()
{
    int i,j;
    link adj[7];
    for(i=0;i<7;i++)
        adj[i] = NULL;
    while (scanf("%d%d",&i,&j) == 2)
    {
        adj[j] = NEW(i,adj[j]);
        adj[i] = NEW(j,adj[i]);
    }
    return 0;
}

hoshelly 2012-08-19 20:37 发表评论

囄��L��矩阵表示

hoshelly — Sun, 19 Aug 2012 11:46:00 GMT
代码如下�Q?br />
#include
#include
int main()
{
    int i,j,adj[7][7];
    for(i=0;i<7;i++)
        for(j=0;j<7;j++)
            adj[i][j] = 0;
    for(i=0;i<7;i++)
        adj[i][i] = 1;
    while(scanf("%d%d",&i,&j) == 2)
    {
        adj[i][j] = 1;
        adj[j][i] = 1;
    }
    for(i=0;i<7;i++)
    {
        for(j=0;j<7;j++)
        {
            printf("%d ",adj[i][j]);
        }
        printf("\n");
    }
    return 0;
}

�l�果截图�Q?br />

hoshelly 2012-08-19 19:46 发表评论

填充二维数组

hoshelly — Sun, 19 Aug 2012 08:22:00 GMT
�~�写一�E�序�Q�用0�?填充一个二�l�数�l�，如果i 和j 的最大公因子�?�Q�则设a[i][j]�?�Q�否则设�?�?br />
代码如下�Q?br />
#include
#define N 10
int Maxcom(int a, int b)
{
    while(a!=b)
    {
        if(a>b)
            a=a-b;
        else if(b>a)
            b=b-a;
    }
    return a;
}
int main()
{
    int a[N][N];
    int i,j,max;
    for(i=0;i<5;i++)
    {
        for(j=0;j<5;j++)
        {
            if(i==1 && j==1)
                a[i][j]=1;
            else if( i>0 && j>0)
            {
                max = Maxcom(i,j);
                if(max == 1)
                    a[i][j]=1;
                else
                    a[i][j]=0;
            }
            else
                a[i][j]=0;
        }
    }
    for(i=0;i<5;i++)
    {
        for(j=0;j<5;j++)
            printf("%d ",a[i][j]);
        printf("\n");
    }
    printf("\n");

    return 0;
}

hoshelly 2012-08-19 16:22 发表评论

hoshelly — Thu, 16 Aug 2012 17:43:00 GMT
�~�写一个返回��@环链表中节点数的函数

实现代码如下�Q?br />
#include
#include
typedef struct node *link;
struct node{ int item; link next; };

int node_number(link p,int n)
{
    int count=0,i;
    for(i=0;i    {
        p=p->next;
    }
    while(p->item)
    {
        p->item=0;
        p=p->next;
        count++;
    }
    return count;
}

int main()
{

    int i,N;
    link t=(link)malloc(sizeof(node));
    t->item=1;
    t->next=t;
    link x=t;
    for(i=2;i<=10;i++)
    {
        x = (x->next= (link)malloc(sizeof(node)));
        x->item=i;
        x->next=t;
    }
    printf("Please input the order of node: ");
    scanf("%d",&N);
    printf("total number of nodes is: %d\n",node_number(t,N));
    return 0;
}

hoshelly 2012-08-17 01:43 发表评论

hoshelly — Thu, 16 Aug 2012 16:14:00 GMT
假设有N个�h军_��选出一个领��g�h�Q�方法如下：所有�h排成一个圆圈，按顺序数敎ͼ�每隔�W�M个�h出局�Q�此时他两边的�h靠拢重新形成圆圈。问题是扑և�哪一个�h��会是最后剩下的那个人。我们希望打印出所有�h的出局��序和最后选出的领��g�h是哪一位�?br />
�q�个问题�U�Cؓ�U�瑟夫问题，可以利用链表解决�?br />
代码如下�Q?br />
  //�U�瑟夫问�?/span>

  #include
  #include
  typedef struct node *link;
  struct node { int item; link next; }; //定义�l�点
  int main()
  {
   int i,N,M;
printf("Input N and M: "); //N表示共有N个�h�Q�M表示每隔�W�M个�h要出局
     scanf("%d%d",&N,&M);
link t = (link)malloc(sizeof(node)); //新徏�l�点t
     link x=t;
t->item = 1; t->next=t; //创徏一个代�?��L��单个节点的��@环链�?/span>
     for(i=2;i<=N;i++)
{
x=(x->next= (link)malloc(sizeof(node)));//��?~N��h��序插��C��前创建的单个节点的��@环链表中
         x->item=i; x->next=t;
}

while(x!= x->next) //如果不是最后一个节点，因�ؓ是��@环链表，所以x!=x->next
     {
for(i=1;i//则顺着链表向前遍历�Q�数出M-1个元�?/span>
             x=x->next;
printf("%d ",x->next->item);
x->next = x->next->next; //删除�W�M个元�?/span>
         N--; //节点数减1
     }
printf("\n%d\n",x->item); //最后打印出最后一个节�?/span>
     return 0;
}

hoshelly 2012-08-17 00:14 发表评论

最�q�点对的计算

hoshelly — Tue, 14 Aug 2012 13:39:00 GMT
�~�写�E�序�Q�对于N个随��Z�生的单位正方形中的点�Q�统计可以被长度��于d的直�U�连�l�的点对数�?br />
�E�序如下�Q?br />
typedef struct{ float x; float y; } point; //定义点的数据�c�d��
float distance(point,point); //两点之间距离函数
float distance(point a,point b)
{
   float dx= a.x - b.x, dy= a.y - b.y;
   return sqrt(dx*dx + dy*dy);
}
//以上为头文�g Point.h 的内�?/span>

#include
#include
#include
#include "Point.h"
float randFloat()
{  return 1.0*rand()/RAND_MAX; } //产生随机数的函数
int main()
{
    float d,N;
    int i,j,cnt=0;
    scanf("%f%f",&d,&N); //d��求两点之间距��d��于的长度�Q�N为测试的�?nbsp;
    point *a = (point *)malloc(sizeof(point)*N); //动态生成数据类型�ؓpoint的数�l�a
for(i=0;i
{
a[i].x = randFloat(); a[i].y = randFloat();
}
    for(i=0;i        for(j=i+1;j            if(distance(a[i],a[j])//如果两点之间的距��d��于d�Q�那么cnt�?
cnt++;
    printf("%d edges shorter than %f\n",cnt,d); //输出有多��条边的长度��于d
    return 0;
}

hoshelly 2012-08-14 21:39 发表评论

埃拉托色��筛选法

hoshelly — Mon, 13 Aug 2012 14:17:00 GMT
// From < C Programming FAQs >
扑և�所有小�?0000的素敎ͼ��法原理误��行google 埃拉托色��筛�?br />
�E�序代码�Q?br />

#define N 10000
#include
int main()
{
    int i,j,a[N];
    for(i=2;i//��数�l�中的值全部设�?
    for(i=2;i        if(a[i])
            for(j=i;i*j//��烦引�ؓ2,3,5�Q?img src="http://www.shnenglu.com/Images/dot.gif" alt="" />的倍数的数�l�元素设�?�Q�因��些数不是素数
    for(i=2;i        if(a[i]) printf("4%d\n",i); //遍历打印出找到的素数
    printf("\n");
    return 0;
}

hoshelly 2012-08-13 22:17 发表评论

用链表实现学生成�l�的排序

hoshelly — Sun, 12 Aug 2012 14:23:00 GMT
输入10个学生的成�W�Q�编写一�E�序对学生的成�W按从高到低输出，要求用链表实现�?br />
#include
#include
struct Stu
{
    int score;
    struct Stu *next;
};
typedef struct Stu Node;
int main()
{
    int i;
    Node *head,*p,*q;
    head=(Node*)malloc(sizeof(Node)); //创徏头结�?/span>
    if(head == NULL)
    {
        printf("Memory is not enough!");
        return 0;
    }
    head->next=NULL;
    for(i=0;i<10;i++)
    {
        p=(Node*)malloc(sizeof(Node)); //创徏一个新�l�点p
        if(p == NULL)
        {
            printf("no enough memory!");
            return 0;
        }
        printf("Input the %dth student's score: ",i+1);
        scanf("%d",&p->score); //输入成�W
        q=head;
        while(q->next != NULL) //遍历链表
        {
            if(q->next->score < p->score) //如果发现链表中的某个成�W比当前输入成�l�小�Q�就跛_��循环�Q�在其前面插入当前输入成�l?/span>
                break;
            q=q->next; //�l�箋遍历直到遍历的成�l�比当前输入的成�l�小
        }
        p->next=q->next; //�q�是当前成�W插入到链表中比其��的成�W前面的代�?/span>
        q->next=p;

    }
    p=head->next;
    while(p !=NULL)
    {
        printf("%d ",p->score);
        p=p->next;
    }

p=head;
while(p->next !=NULL)
{
    q=p->next;
    p->next=q->next;
    free(q);
}
free(head);

return 0;
}

hoshelly 2012-08-12 22:23 发表评论

hoshelly — Sat, 12 May 2012 02:29:00 GMT

建立一个链表，其中的节点包括学��P��成�W信息。要求用动态插入链表的�Ҏ��实现�Q�就是输入第一个节点信息时�Q�则必须创徏该链表，之后每输入一个学生节点的基本信息�Q�就把该节点插入到已有的链表当中。要求按照学号顺序插入。输入的时候可以不按照学号的顺序，输入0 0 �?/div>
�C��入结束�?/div>
�Q�不允许对输入的数据排序后再创徏链表�Q?br />
Sample Input

1 50
4 60
2 70
3 80
5 64
0 0

Sample Output

The list is:
1 50
2 70
3 80
4 60
5 64

#include
#include

struct student
{
    int number;
    float score;
    struct student *next;
};

int main()
{
    int n=0;
    struct student *head,*p1;
    p1=(struct student*)malloc(sizeof(struct student));
    scanf("%d %f",&p1->number,&p1->score);
    head=p1;
    head->next=NULL;
    while(p1->number!=0 && p1->score!=0)
    {
          n++;
          p1->next=(struct student*)malloc(sizeof(struct student));
          p1=p1->next;
          p1->next=NULL;
          scanf("%d %f",&p1->number,&p1->score);
    }

    struct student *p3,*p4;
    p3=(struct student*)malloc(sizeof(struct student));
    p4=(struct student*)malloc(sizeof(struct student));
    for(int i=0;i    {
        p3=head;
        for(int j=0;j        {
            p4=p3->next;
            if(p3->number>p4->number)
            {
                int k=p3->number;
                p3->number=p4->number;
                p4->number=k;
                float m=p3->score;
                p3->score=p4->score;
                p4->score=m;
            }
            p3=p3->next;
        }
    }
    printf("The list is:\n");
     p3=head;
     do
     {
      if(p3->number ==0 && p3->score==0)
          continue;
      printf("%d %.0f\n",p3->number,p3->score);
      p3=p3->next;
    }while(p3!=NULL);

    free(p1);
    free(p3);
    free(p4);
    return 0;
}


hoshelly 2012-05-12 10:29 发表评论

hoshelly — Sun, 04 Mar 2012 09:14:00 GMT

#include<stdio.h>
void swap(int *a,int *b)
{
    int tmp;
    tmp=*a;
    *a=*b;
    *b=tmp;
}

void quicksort(int 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));//重复执行i++操作
            do j--;
            while(!(k[s]<=k[j] || j==s));//重复执行j--操作

            if(i<j)
                swap(&k[i],&k[j]); //交换k[i]和k[j]的位�|?/span>
            else
                break;
        }
        swap(&k[s],&k[j]);   //交换基准元素与k[j]的位�|?/span>
        quicksort(k,s,j-1);  //递归排序基准元素前面的子序列
        quicksort(k,j+1,t);  //递归排序基准元素后面的子序列
    }
}

int main()
{
    int k[10]={2,5,6,3,7,8,0,9,12,1},i;
    printf("The orginal data array is\n");
    for(i=0;i<10;i++)
        printf("%d ",k[i]);
    quicksort(k,0,9);  //从大到小排序
    printf("\nThe result of quick sorting for the array is\n");
    for(i=0;i<10;i++)
        printf("%d ",k[i]);
    return 0;
}

hoshelly 2012-03-04 17:14 发表评论

希尔排序

hoshelly — Sun, 04 Mar 2012 08:13:00 GMT

//希尔排序��法思想�Q�羃��增量gap->划分序列->��每个子序列排序
#include<stdio.h>
void shellsort(int k[],int n)
{
    int i,j,flag,gap=n;
    int 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);
    }
}

int main()
{
    int i,a[11]={-111,2,5,6,3,7,8,0,9,12,1};
    printf("The orginal data array is\n");
    for(i=1;i<=10;i++)
        printf("%d ",a[i]);

    shellsort(a,10);

    printf("\nThe result of Shell's sorting for the array is\n");//从大到小排序
    for(i=1;i<=10;i++)
        printf("%d ",a[i]);
    return 0;
}

hoshelly 2012-03-04 16:13 发表评论

直接插入排序

hoshelly — Sun, 04 Mar 2012 07:19:00 GMT

#include<stdio.h>
int insertsort(int a[],int n)//直接排序�?/span>
{
    int i,j;
    for(i=2;i<=n;i++)
    {
        a[0]=a[i]; //a[0]作�ؓ临时变量存储a[i]
        j=i-1;
        while(j>0 && a[0]>a[j])//从大到小排列
            a[j+1]=a[j--];
        a[j+1]=a[0]; //��元素a[0]插入指定位置
    }
    return 0;
}

int main()
{
    int i,a[11]={-111,2,5,6,3,7,8,0,9,12,1};//a[0]没有使用
    printf("The orginal data array is\n");
    for(i=1;i<=10;i++)
        printf("%d ",a[i]);
    insertsort(a,10);
    printf("\nThe result of insertion sorting for the array is\n");
    for(i=1;i<=10;i++)
        printf("%d ",a[i]);
    printf("\n");
    return 0;
}

hoshelly 2012-03-04 15:19 发表评论

用先序序列创��Z��叉树

hoshelly — Sat, 03 Mar 2012 12:05:00 GMT

#include<stdio.h> //用先序序列创��Z��二叉树�Q��ƈ输出字符D位于二叉树的层数
#include<stdlib.h>
#include<conio.h>
typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

CreatBiTree(BiTree *T)
{
    char c;
    scanf("%c",&c);
    if(c == ' ') *T=NULL; //如果输出的是�I�格�Q�则表示创徏的子树结�?/span>
    else
    {
        *T=(BiTNode*)malloc(sizeof(BiTNode)); //创徏根结�?/span>
        (*T)->data=c; //向根�l�点中输入数�?/span>
        CreatBiTree(&((*T)->lchild)); //递归地创建左子树
        CreatBiTree(&((*T)->rchild)); //递归地创建右子树
    }
}
//讉K��二叉树结点，输出包含D字符�l�点位于二叉树中的层�?/span>
visit(char c,int level)
{
    if(c=='D')
        printf("%c is at %d lever of BiTree\n",c,level);
}
PreOrderTraverse(BiTree T,int level)
{
    if(T)    //递归�l�束条�g�Q�T为空
    {
        visit(T->data,level);//讉K��根结�?/span>
        PreOrderTraverse(T->lchild,level+1);
        PreOrderTraverse(T->rchild,level+1);
    }
}

int main()
{
    int level=1;
    BiTree T=NULL; //最开始T指向�I?/span>
    CreatBiTree(&T);
    PreOrderTraverse(T,level);
    getche();
    return 0;
}

hoshelly 2012-03-03 20:05 发表评论

hoshelly — Sat, 03 Mar 2012 10:42:00 GMT

//队列的基本操作：实现一个链队列�Q��Q意输入一串字�W�，以@为结束标志，然后��队列中的元素逐一取出�Q�打印在屏幕�?/span>
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
typedef char ElemType;
typedef struct QNode
{
    ElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
    QueuePtr front; //队头指针
    QueuePtr rear;  //队尾指针
}LinkQueue;

initQueue(LinkQueue *q) //创徏一个头�l�点�Q�队头队��指针指向该�l�点
{
    q->front=q->rear=(QueuePtr)malloc(sizeof(QNode));

    if(!q->front) exit(0);
    q->front->next=NULL;
}

EnQueue(LinkQueue *q,ElemType e)
{
    QueuePtr p;
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!q->front) exit(0);
    p->data=e;      //数据e入列
    p->next=NULL;
    q->rear->next=p;
    q->rear=p;
}

DeQueue(LinkQueue *q,ElemType *e)//如果队列q不�ؓ�I�，删除q的队头元素，用e�q�回其�?/span>
{
    QueuePtr p;
    if(q->front==q->rear) return; //队列为空�Q�返�?/span>
    p=q->front->next;
    *e=p->data;
    q->front->next=p->next;
    if(q->rear==p) q->rear=q->front;//如果队头��是队尾�Q�则修改队尾指针
    free(p);
}

int main()
{
    ElemType e;
    LinkQueue q;
    initQueue(&q);
    printf("Please input a string into a queue\n");
    scanf("%c",&e);
    while(e!='@')
    {
        EnQueue(&q,e);
        scanf("%c",&e);
    }
    printf("The string into the queue is\n");
    while(q.front!=q.rear)
    {
        DeQueue(&q,&e);
        printf("%c",e);
    }

    printf("\n");
    getche();
    return 0;
}

hoshelly 2012-03-03 18:42 发表评论

hoshelly — Sat, 03 Mar 2012 06:06:00 GMT

//二进制�{换�ؓ十进制数�Q�利用栈的数据结构）
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<conio.h>
#define STACK_INIT_SIZE 20
#define STACKINCREMENT 10

typedef char ElemType;
typedef struct{
    ElemType *base;
    ElemType *top;
    int stacksize;
}sqStack;

initStack(sqStack *s) //创徏一个栈
{
    s->base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));
    if(!s->base)  exit(0);
    s->top=s->base;
    s->stacksize=STACK_INIT_SIZE;
}
Push(sqStack *s,ElemType e){
    if(s->top-s->base>=s->stacksize){
        s->base=(ElemType*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType));
        if(!s->base) exit(0);
        s->top=s->base+s->stacksize;
        s->stacksize=s->stacksize+STACKINCREMENT;
    }
    *(s->top)=e;
    s->top++;
}

Pop(sqStack *s,ElemType *e){
    if(s->top==s->base) return;
    *e=*--(s->top);
}

int StackLen(sqStack s){ //计算栈的当前定w��
    return (s.top-s.base);
}

int main()
{
    ElemType c;
    sqStack s;   //�?/span>
    int len,i,sum=0;
    printf("Please input a Binary digit\n");

    initStack(&s);
    //输入0/1字符表示的二�q�制敎ͼ��?�l�束

    scanf("%c",&c);
    while(c!='#')
    {
        Push(&s,c);
        scanf("%c",&c);
    }
    getchar();
    len=StackLen(s);

    for(i=0;i<len;i++)
    {
        Pop(&s,&c);
        sum=sum+(c-48)*pow(2,i);//c-48是�ؓ了得到该字符对应�?/1��|��q�是因�ؓ字符0的ASCII码�ؓ48
    }
    printf("Decimal is %d\n",sum);
    getche();
    return 0;
}

//清空一个栈代码
ClearStack(sqStack *s)
{
    s->top=s->base;
}

//销毁一个栈代码

DestroyStack(sqStack *s)
{
    int i,len;
    len=s->stacksize;
    for(i=0;i<len;i++)
    {
        free(s->base);
        s->base++;
    }
    s->base=s->top=NULL;
    s->stacksize=0;
}

hoshelly 2012-03-03 14:06 发表评论

hoshelly — Thu, 01 Mar 2012 03:49:00 GMT
要求�Q�从�l�端输入一�l�整敎ͼ�大于10�Q�，�?作�ؓ�l�束标志�Q�将�q�一�l�整数存攑֜�一个链表中�Q�结束标�?不包括在内）�Q�打印出该链表中的倹{��然后删除该链表的第5个元素，打印出删除后的结果。最后在内存中释放掉该链表�?br />源程序如下：

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
typedef int ElemType;
typedef struct node{
    ElemType data;
    struct node *next;
}LNode,*LinkList;

LinkList GreatLinkList(int n){
    LinkList p,r,list=NULL;
    ElemType e;
    int i;
    for(i=1;i<=n;i++)
    {
        scanf("%d",&e);
        p=(LinkList)malloc(sizeof(LNode));
        p->data=e;
        p->next=NULL;
        if(!list)
            list=p; //如果list为空�Q�则说明本次生成的结点�ؓ�W�一个结点，��p赋给list
        else
            r->next=p;//否则��p赋给r->next�Q�这里r永远指向原先链表的最后一个结点，也就是要插入�l�点的前一个结�?/span>
        r=p;
    }
    return list;//�q�回链表头指�?/span>
}

void insertList(LinkList *list,LinkList q,ElemType e)
{
    LinkList p;
    p=(LinkList)malloc(sizeof(LNode));
    p->data=e;
    if(!*list){ //当链表�ؓ�I�时�Q�将p赋给list�Q�p的next域的值置为空
        *list=p;
        p->next=NULL;
    }
    else
    {
        p->next=q->next;//q为插入指针指向的�l�点
        q->next=p;
    }
}

void delLink(LinkList *list,LinkList q){
    LinkList r;
    if(q==*list)//如果删除�W�一个结�?/span>
    {
        *list=q->next;
        free(q);
    }
    else //删除其他�l�点
    {
        for(r=*list;r->next!=q;r=r->next);//当q所指向的结点的前驱�l�点的指针未知时�Q�需要先通过链表头指针list遍历链表�Q?br />                                           //扑ֈ�q的前��q��点的指针�Q��ƈ把该指针赋值给指针变量r
        if(r->next!=NULL){
            r->next=q->next;
            free(q);
        }
    }
}

void destroyLinkList(LinkList *list){
    LinkList p,q;
    p=*list;
    while(p)//循环释放掉每个链表结�?/span>
    {
        q=p->next;
        free(p);
        p=q;
    }
    *list=NULL;//��该链表完全�|�空�Q�防止list变成野指�?/span>
}

void main()
{
    int e,i;
    LinkList l,q;
    q=l=GreatLinkList(1);//创徏链表一个结点，q和l指向该结�?/span>
    scanf("%d",&e);
    while(e) //循环输入数据�Q�同时插入新生成的结�?/span>
    {
        insertList(&l,q,e);
        q=q->next;
        scanf("%d",&e);
    }
    q=l;
    printf("The content of the linklist\n");
    while(q) //输出链表中的内容
    {
        printf("%d ",q->data);
        q=q->next;
    }
    q=l;
    printf("\nDelete teh fifthe element\n");
    for(i=0;i<4;i++)
    {
        q=q->next;
    }//��指针q指向链表的第5个元�?/span>

    delLink(&l,q);
    q=l;
    while(q)
    {
        printf("%d ",q->data);
        q=q->next;
    }
    destroyLinkList(&l);
    getche();//输入后立即从控制台取字符�Q�不以回车�ؓ�l�束(带回�?
}

hoshelly 2012-03-01 11:49 发表评论

久久99精品国产麻豆,久久se精品一区二区影院 ,久久人人超碰精品CAOPOREN

归�ƈ排序���法及其实现代码详解

动态规划解�?1背包问题

二叉树之数组存储

前缀表达式求值的递归�E�序

一元多��式相加实现

中缀--后缀转换

二分搜烦���法

归�ƈ两个�U�性表得到新的�U�性表

�U�性表基本操作

囄�����L��矩阵表示

填充二维数组

最�q�点对的计算

埃拉托色���筛选法

用链表实现学生成�l�的排序

Sample Input1 504 602 703 805 640 0 Sample OutputThe list is:1 502 703 804 605 64

希尔排序

直接插入排序

用先序序列创��Z��叉树

归�ƈ排序��法及其实现代码详解

二分搜烦��法

囄��L��矩阵表示

埃拉托色��筛选法

Sample Input

1 50
4 60
2 70
3 80
5 64
0 0

Sample Output

The list is:
1 50
2 70
3 80
4 60
5 64