C++博客-_飞寒の魂器.h-随笔分类-数据结构

PKU 2777 Count Color 线段树+位运算

_飞寒 — Sun, 20 Feb 2011 05:39:00 GMT

    查询和修改给定区间的颜色种类，将一个区间的颜色种类k用二进制数2^k表达，位运算求或即可得出任意区间的不同颜色种类。
    查询量巨大，建议按线段更新，不要每次都更新到树叶。
    我也不明白我的程序怎么那么慢。。。求xxms做法。

1/*Source Code
2
3Problem: 2777        User: _mTy
4Memory: 4024K        Time: 329MS
5Language: C++        Result: Accepted
6
7*/
8#include<stdio.h>
9#include<string.h>
10#define MAXV 666666
11#define swap(a,b) a^=b^=a^=b
12
13typedef unsigned long _UL;
14typedef _UL ele_t;
15ele_t data[MAXV];
16int B[MAXV],E[MAXV],LSON[MAXV],RSON[MAXV],C[MAXV];
17int cnt;
18bool fill[MAXV];
19// B[] E[] 存放 [a,b]左界右界
20// C[] 覆盖当前区间的线段数
21// LSON,RSON 点v的左右儿子的数组下标
22//  fill[] 指示特定区间是否仅被一种颜色填充
23
24void ini(int u,int v){
25   int i;
26   ++cnt; i = cnt; B[i] = u; E[i] = v;
27   if( v - u >= 1 ){
28      LSON[i] = cnt+1; ini(u,(u+v)/2);
29      RSON[i] = cnt+1; ini((u+v)/2+1,v);
30   }
31}
32
33void insert(int u,int v,int r,ele_t ele){    // 将区间[u,v]信息 data 插入以 r 为根的线段树
34    if( u <= B[r] && v >= E[r] ){
35        data[r] = 1UL<<ele-1;
36        fill[r] = 1;
37    }else{
38        if( fill[r] == 1 ){ data[LSON[r]] = data[RSON[r]] = data[r]; fill[LSON[r]] = fill[RSON[r]] = 1; }
39
40        if( u <= (B[r]+E[r])/2 ) insert(u,v,LSON[r],ele);
41        if( v >= (B[r]+E[r])/2+1 ) insert(u,v,RSON[r],ele);
42
43        // updata [u,v]
44        data[r] = data[LSON[r]] | data[RSON[r]];
45        fill[r] = 0;
46    }
47}
48
49_UL out(int u,int v,int r){
50    int data_1 = 0,data_2 = 0;
51    if( fill[r] == 1 || u <= B[r] && v >= E[r] ) return data[r];
52    else{
53        if( u <= (B[r]+E[r])/2 ) data_1 = out(u,v,LSON[r]);
54        if( v >= (B[r]+E[r])/2+1 ) data_2 = out(u,v,RSON[r]);
55        return data_1 | data_2;
56    }
57}
58
59int main(){
60    int i,j,l,t,o,u,v,cc,res;
61    _UL val;
62    char chr;
63    while(scanf("%d%d%d",&l,&t,&o)!=EOF){
64        getchar();
65
66        data[1] = 1UL;
67        cnt = 0; ini(1,l);
68        memset(fill,0,sizeof(bool)*(cnt+1));  fill[1] = 1; // 初始区间 [u,v] 被1颜色填充
69
70        for(i=0;i<o;i++){
71            scanf("%c%d%d",&chr,&u,&v);
72            if( u>v ) swap(u,v);
73            if( chr == 'C' ){
74                scanf("%d",&cc);
75                getchar();
76                insert(u,v,1,cc);
77            }else{
78                getchar();
79                val = out(u,v,1);
80                res = 0;
81                for(j=0;j<t;j++) if( val & 1UL<< j ) ++res;
82                printf("%d\n",res);
83            }
84        }
85    }
86    return 0;
87}

_飞寒 2011-02-20 13:39 发表评论

PKU 1928 The Peanuts

_飞寒 — Sat, 22 Jan 2011 16:16:00 GMT

     本来今晚不想写代码的，结果改写了下Bell_Ford的一道题后看了下提交记录，发现了这道题自己居然一直没过。这道题是上一年寒假回来选拔珠海赛时候的练习题了，不知道怎么形容，看到这道题心里很不是滋味，无法想像一年前的自己怎么发挥的这么窝囊，从选拔一直到中大赛，一路水得一塌糊涂。一气之下再扫了遍题目，打开编译器十五分钟写完1A秒过，这以前以后，惆怅啊。但愿今年顺顺利利，比赛要好，学习也要好。最重要的是，我在乎的人也要好。。。等我回中大争气给你看！

      题意略去，就是嘟嘟捡花生，排序花生坐标，贪心尝试即可。注意捡下一个花生要保证时间足够出去。

1#include<cstdio>
2#include<cstdlib>
3#include<cstring>
4#define N 55
5struct nod{int u,v,val;};
6struct nod p[N*N];
7
8int cmp(const void *p,const void *q){
9    return ((struct nod *) q)->val-((struct nod *) p)->val;
10}
11
12int main(){
13    int n,m,time;
14    int t,i,j,k,total;
15    int posu,posv,res;
16    scanf("%d",&t);
17    while(t--){
18        scanf("%d%d%d",&n,&m,&time);
19        total=0;
20        for(i=0;i<n;i++)
21            for(j=0;j<m;j++){
22                scanf("%d",&k);
23                if(k){
24                    p[total].u=i;
25                    p[total].v=j;
26                    p[total].val=k;
27                    total++;
28                }
29            }
30        qsort(p,total,sizeof(p[0]),cmp);
31
32        time-=2;
33        res=0;
34        posu=0; posv=p[0].v;
35        for(i=0;i<total;i++){
36            if( time-abs(p[i].u-posu)-abs(p[i].v-posv)
37                - p[i].u -1 >=0 ){
38                time-=abs(p[i].u-posu)+abs(p[i].v-posv)+1;
39                res+=p[i].val;
40                posu=p[i].u;
41                posv=p[i].v;
42            }
43            else break;
44        }
45        printf("%d\n",res);
46    }
47    return 0;
48}

_飞寒 2011-01-23 00:16 发表评论

AVL树 - ADT实现

_飞寒 — Mon, 20 Dec 2010 14:20:00 GMT

AVL树是最老的带有平衡条件的二叉查询树，高度严格控制为 s(h) = s(h-1)+s(h-2)+1。因此符合斐波那契数列，因此容易推出它的高度上界为 1.44log(N+2)-1.328。 ADT没有给出删除操作的调整操作，删除操作的代码量稍大，可以采用惰性操作。时刻保持更新的高度信息可以使树最多失衡2的高度差，并立即被调整。其中可能会涉及四种调整操作的情况：
  1. 向左儿子的左子树插入，向右单旋转
  2. 向右儿子的右子树插入，向左单旋转
  3. 向左儿子的右子树插入，双旋转.1
  4. 向右儿子的左子树插入，双旋转.2

容易证明，1和2情况是镜像对称的；3和4同理，但编码时要仔细区分。

#ifndef // _AvlTree_H

struct Avlnod;
typedef struct Avlnod *Position;
typedef struct Avlnod *AvlTree;

AvlTree MakeEmpty( AvlTree T );
Position Find( ElementType X, AvlTree T );
Position FindMin( AvlTree T );
Position FindMax( AvlTree T );
AvlTree Insert( ElementType X, AvlTree T );
AvlTree Delete( ElementType X, AvlTree T );
ElementType Retrieve( Position P );

struct AvlNode{
ElementType ele;
AvlTree left;
AvlTree right;
int height;
}:

AvlTree Insert( ElementType x, AvlTree t ){
if( null == t ){
  t = ( AvlTree )malloc( sizeof( struct AvlNode ) );
  if( null == t ){
   printf(" error ");
  }
  else{
   t->ele = x; t->height = 0;
   t->left = null; t->right = null;
  }
}
else{
  if( x < t->ele ){
   t = Insert( x ,t->left );
   if( 2 == getHeight( t->left ) - getHeight( t->right )  ){
    if( x < t->left->ele ){
     t = SingleRoRight( t );
    }
    else{
     t = DoubleRoRight( t );
    }
   }
  }
  else
   if( x > t->ele ){
    t = Insert( x ,t->right );
    if( 2 == getHeight( t->right ) - getHeight( t->left )  ){
     if( x > t->right->ele ){
      t = SingleRouLeft( t );
     }
     else{
      t = DoubleRouLeft( t );
     }
    }
   }
}
t->height = max( getHeight( t->left ) ,getHeight( t->right ) )+1;
return t;
}

AvlTree SingleRouRight( AvlTree root2 ){
Position root1;
root1 = root2->left;
root2->left = root1->right;
root1->right = root2;
root2->height = max( getHeight( root2->left ) ,getHeight( root2->right ) )+1;
root1->height = max( getHeight( root1->left ) ,getHeight( root1->right ) )+1;
return root1;
}

AvlTree DoubleRouRight( AvlTree root3 ){
Position rootTmp,root;
rootTmp = root3->left;
root3->left = SingleRouLeft( rootTmp );   // 左旋左子树
root = SingleRouRight( root3 );  // 右旋整体
return root;
}

AvlTree SingleRouLeft( AvlTree root1 ){
Position root2;
root2 = root1->right;
root1->right = root2->left;
root2->left = root1;
root1->height = max( getHeight( root1->left ) ,getHeight( root1->right ) )+1;
root2->height = max( getHeight( root2->left ) ,getHeight( root2->right ) )+1;
return root2;
}

AvlTree DoubleRouLeft( AvlTree root3 ){
Position rootTmp,root;
rootTmp = root3->right;
root3->right = SingleRouRight( rootTmp );   // 右旋右子树
root = SingleRouLeft( root3 );  // 左旋整体
return root;
}

#endif  // _AvlTree_H

_飞寒 2010-12-20 22:20 发表评论

不相交集_ADT

_飞寒 — Mon, 20 Dec 2010 13:17:00 GMT

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

#ifndef _DisjSet_H

typedef int DisjSet[NumSets+1];
typedef int setType;
typedef int ElementType;

void Initilialize(DisjSet S);
setType Find_semplice(ElementType x,DisjSet s);
setType Find_path_compression(ElementType x,DisjSet s);
void SetUnion_semplice(DisjSet s,setType Root1,setType Root2);

#endif _DisjSet_H

void Initilialize(DisjSet s)
{
      for(int step=1;step<NumSets+1;step++)

      }

setType Find_semplice(ElementType x,DisjSet s)
{
      if(s[x]<1) return x;
      else
          return Find(s[x],s);
      }

setType Find_path_compression(ElementType x,DisjSet s)
{
      if(s[x]<1) return x;
      else
          return s[x]=Find(s[x],s);
      }
void SetUnion_semplice(DisjSet s,setType Root1,setType Root2)
{
      s[Root2]=Root1;
      }

void SetUnion_number(DisijSet s,setType Root1,setType Root2)
{
      if(s[Root1]<s[Root2])  // 1树容量更大
         {
             s[Root1]+=s[Root2];  // 增加树容量
             s[Root2]=Root1;
             }
      else
          {
              s[Root2]+=s[Root1];
              s[Root1]=Root2;
              }
      }

void SetUnion_deep(DisijSet s,setType Root1,setType Root2)
{
      if(s[Root1]<s[Root2])  s[Root2]=Root1;
      else
      {
         if(s[Root1]==s[Root2])
            s[Root2]--;
         s[Root1]= Root2;
         }

      }

_飞寒 2010-12-20 21:17 发表评论

开放定址法_ADT

_飞寒 — Mon, 20 Dec 2010 13:14:00 GMT

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

#inndef _HashQuad_h

typedef unsigned int Index;
typedef Index Pos;

struct HashTbl;
typedef struct HashTbl *Table;

Table newHash(int);
Pos Find(ElementType,Table);
void Insert(ElementType,Table);
Table ReHash(Table);

#endif

struct HashEntry
{
   ElementType ele;
   int info;
       };

struct HashEntry;
typedef HashEntry Cell;

struct HashTbl
{
  int tableSize;
  Cell *theCell;
       };

Table newHash(int tableSize)
{
   Table h;
   int i;
  if(tableSize<minTableSize)
     return NULL;
  h=(Table)malloc(sizeof(struct HashTbl));
  h->tableSize=nextPrime(tableSize);
  h->theCell=(Cell *)malloc(sizeof(Cell)*h->tableSize);
  for(i=0;i<h->tableSize;i++)
     *(h->theCell+i).info=0;
  return h;
}

Pos Find(ElementType x,Table h)
{
   Pos currentPos;
   int j=0;

   currentPos=HashFunction(x,h->tableSize);
   while(*(h->theCell+currentPos).info!=0&&fcmp(*(h->theCell+currentPos).ele,x)!=1)
   {
      currentPos+=(2* ++j)-1;

      if(currentPos>=h->tableSize)  // 小心边界
         currentPos-=h->tableSize;
   }
   return currentPos;
}

void Insert(ElementType x,Table h)
{
   Pos aim;
   aim=Find(x,h);
   if(h->theCell[aim].info==0)
   {
     fcpy(h->theCell[aim].ele,x);
     h->theCell[aim].info=1;
   }
}

Table ReHash(Table oldTbl)
{
   Table h;
   int oldSize;

   oldSize=oldTbl->tableSize;
   h=newHash(2*oldSize);
   for(int i=0;i<oldSize;i++)
   {
     if(oldTbl->theCell[i].info==1)
        Insert(oldTbl->theCell[i].ele,h);
   }
   free(oldTbl);
   return h;
}

_飞寒 2010-12-20 21:14 发表评论

二叉查询树_ADT

_飞寒 — Mon, 20 Dec 2010 13:13:00 GMT

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

#ifndef _Tree_H

typedef struct searchTreeNode *tree;
typedef *searchTree *position;

struct serachTreeNode
{
   ElementType element;
   ptr left;
   ptr right;
       };

tree MakeEmpty(tree);
position Find(ElementType,tree);
position FindMin(tree);
position FindMax(tree);
tree Insert(ElementType,tree);
ElementType Retrieve(position);
tree Delete(ElementType,tree);

#endif

tree MakeEmpty(tree t)
{
   if(t!=NULL)
   {
     MakeEmpty(t->left);
     MakeEmpty(t->right);
     free(t);
   }
     return NULL;
}

tree Find(ElementType x,tree t)
{
   if(t!=NULL)
   {
      if(compare(x,p->element)==-1)
         return Find(x,t->left);
      else
         if(compare(x,p->element)==1)
            return Find(x,t->right);
         else
             return t;
   }
   else
       return NULL;
}

tree FindMin(tree t)
{
   if(t!=NULL)
   {
     while(t->left!=NULL)
          t=t->left;
     return t;
   }
   else
      return NULL;
}

tree FindMax(tree t)
{
   if(t!=NULL)
   {
      if(t->left!=NULL)
         return FindMax(t->right);
   }
   else
      return NULL;
}

tree Insert(Element x,tree t)
{
   if(t==NULL)
   {
      tree tmp=(tree)malloc(sizeof(struct searchTree));
      tmp->element=x;
      tmp->left=tmp->right=NUll;
   }
   else
   {
      if(compare(x,t)==-1)
         t->left=Insert(x,t->left);
      if(compare(x,t)==1)
         t->right=Insert(x,t->right);
   }
   return t;
}

ElementType Retrieve(position p)
{
  return p->Element;
}

_飞寒 2010-12-20 21:13 发表评论

Hash_ADT(分离链路法)

_飞寒 — Mon, 20 Dec 2010 13:13:00 GMT

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

#ifndef _HashSep_H

struct ListNode;
typedef struct ListNode *ptr;
typedef ptr List;

struct HashTable;
typedef struct HashTbl *HashTable

HashTable newHashTable(int);
ptr Find(ElementType,HashTable);
void Insert(ElementType,HashTable);
void DetroyHashTable(HashTable);

#endif

struct ListNode
{
  int element;
  ptr next;
};
struct HashTbl
{
   ElementType TableSize;
   List *TheList;
};

HashTable newHashTable(int TableSize)
{
   if(TableSize<MinTableSize)
      exit(1);  // 散列表尺寸太小
   else
   {
     HashTable h=(HashTable)malloc(sizeof(struct HashTbl));
     if(h==NULL)
        exit(1);  // 分配空间失败
     else
     {
         h->TableSize=prime(TableSize);  // 将用户预定尺寸换成接近的质数
         h->TheList=(List *)malloc(sizeof(List)*h->TableSize);  // 开辟一个数组空间存放指向链表的指针
         if(h->TheList==NULL)
            exit(1);
         else
         {
             for(int step=0;step<h->TableSize;step++)  // 数组初始化，建立一系列表头
             {
                h->TheList[step]=(List)malloc(sizeof(struct ListNode));
                if(h->TheList[step]==NULL)
                   exit(1);
                else
                   h->TheList[step]->next=NULL;
             }
         }
     }
   }
   return h;
}
void Insert(ElementType x,HashTable h)
{
    if(Find(x,h->TheList[hash(x,h->TableSize)])==NULL)
    {
       List tmp=(List)malloc(sizeof(struct ListNode));
            if(tmp==NULL)
               exit(1);
            tmp->element=x;
            tmp=h->TheList[hash(x,h->TableSize)]->next;
            h->TheList[hash(x,h->TableSize)]->next=tmp;
    }
}
ptr Find(ElementType x,HashTable h)
{
    List l=h->TheList[hash(x,h->TableSize)];
    ptr p=l->next;
    while(p!=NULL&&p->element)
         p=p->next;
    return p;
}
void DestroyTable(HashTable h)
{
   for(int step=0;step<h->TableSize;step++)
      DestroyList(h->TheList[step]);
   free(h);
}

_飞寒 2010-12-20 21:13 发表评论

逆波兰-中缀树变换

_飞寒 — Mon, 20 Dec 2010 13:10:00 GMT

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

typedef struct treeNode *ptr;
typedef treeNode tree;

typedef struct stackNode *ptrStack;
typedef ptrStack stack;

struct treeNode
{
   char element;
   ptr left;
   ptr right;
       };

struct stackNode
{
   tree element;
   ptrStack next;
       };

tree polishToTree(char exp[])
{
     int i=0;
     stack s=creatStack();
     while(exp[i]!='\0')
     {
       if(exp[i]!='+'&&exp[i]!='-'&&exp[i]!='*'&&exp[i]!='/')
       {
          tree tmpTree=creatTree();
          tmpTree->element=exp[i];
          tmpTree->left=tmpTree->right=NULL;
          push(tmpTree,s);
       }
       else
       {
           tree tmpTree=creatTree();
           tmpTree->element=exp[i];
           tmpTree->right=top(s);
           pop(s);
           tmpTree->left=top(s);
           pop(s);
           push(tmpTree,s);
       }
       i++;
     }
     tree result=top(s)->element;
     pop(s);
     return result;
}

_飞寒 2010-12-20 21:10 发表评论

前序遍历文件树

_飞寒 — Mon, 20 Dec 2010 13:09:00 GMT

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

typedef struct treeNode *ptr;

struct treeNode
{
   char element[225];
   ptr child;
   ptr brother;
       };

static void listDir(treeNode file,int deep)
{
   if(file!=NULL)
   {
      putout(file->element,deep);
      listDir(file->child,deep+1);
      listDir(file->child,deep);
   }
}

void putout(treeNode name,int deep)
{
     for(int i=0;i<deep;i++)
        printf(" ");
     printf("%s\n",name->element);
}

_飞寒 2010-12-20 21:09 发表评论

后序遍历有权树

_飞寒 — Mon, 20 Dec 2010 13:09:00 GMT

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

typedef struct treeNode *ptr;

struct treeNode
{
   char element[225];
   int size;
   ptr child;
   ptr brother;
       };

int comput(treeNode file,int deep)
{
   int total=0;
   if(file!=NULL)
   {
      total+=file->size;
      total+=comput(file->child,deep+1)+comput(file->brother,deep);
      putout(file,deep);
   }
   return total;
}

void putout(treeNode name,int deep)
{
     for(int step=0;step<deep;step++)
        printf(" ");
     printf("%s     %d\n",name->element,size);
}

_飞寒 2010-12-20 21:09 发表评论

Queue_ADT

_飞寒 — Mon, 20 Dec 2010 13:07:00 GMT

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

#inndef _Queue_h

struct QueueRecord;
typedef struct QqueueRecord *Queue;
struct QueueParameter;
typedef QueueParameter *QueuePar;

QueuePar CreatQueue(int);
int IsEmpty(QueuePar);
int IsFull(QueuePar);
void Enqueue(Element,QueuePar);
void Dequeue(QueuePar);
ElementType Front(QueuePar);
ElementType FrontAndDequeue(QueuePar);
void MakeEmpty(QueuePar);
void DisposeQueue(QueuePar);

#endif

#define SIZE
#define MinQueueSize SIZE

struct QueueRecord
{
   ElementType Element;
   Queue Next;
       };

struct QueueParameter
{
   Queue Front;
   Queue Rear;
   int Size;
   int MaxSize;
       };




   QueuePar CreatQueue(int MaxSize)
   {
      QueuePar q=(QueuePar)malloc(sizeof(struct QueueParameter));
      q->Front=q->Rear=NULL;
      q->Size=0;
      q->MaxSize=MaxSize;
      return q;
   }

   int IsEmpty(QueuePar q)
   {
      return (q->Front==NULL&&q->Rear==NULL);
   }

   int IsFull(QueuePar q)
   {
      int sum=0;
      Queue p=q->Fear;
      while(p!=NULL)
      {
        p=p->Next;
        sum++;
      }
      return sum==q->MaxSize;
   }

   void Enqueue(Element x,QueuePar q)
   {
      if(IsFull(q))
         printf("Full  queue");
      else
     {
        Queue tmp=(Queue)malloc(sizeof(Queue));
        tmp->Element=x;
        tmp->Next=q->Fear;
        q->Fear=tmp;
        q->Size++;
      }
   }

   void Dequeue(QueuePar q)
   {
      if(IsEmpty(q))
         printf("The queue is empty");
      else
      {
        if(q->Front==q->Fear)
        {free(q->Front); Size--;}
        else
        {
          Queue tmp=q->Front;
          Queue p=q->Fear;
          while(p->Next!=q->Front)
               p=p->Next;
          q->Front=p;
          free(tmp);
          Size--;
        }
      }
   }

   ElementType FrontAndDequeue(QueuePar q)
   {
      ElementType tmp=Front(QueuePar q);
      Dequeue(q);
      return tmp;
   }

_飞寒 2010-12-20 21:07 发表评论

List_ADT

_飞寒 — Mon, 20 Dec 2010 13:06:00 GMT

#include<stido.h>
#include<stdlib.h>
#ifndef _Lish_h
struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;
void MakeEmpty(List l);
int IsEmpty(List l);
int IsLast(Position p,List l);
Position Find(ElementType x,List l);
void Delte(ElementType x,List l);
Position FindPrevious(ElementType x,List l);
void Insert(ElementType x,List l,Position p);
void DelList(List l);
Position Header(List l);
Position First(List l);
Position Advance(Position p);
ElementType Retrieve(Position p);
#endif

struct Node
{
  ElementType Element;
  Position Next;
       };

  void MakeEmpty(List l)
  {
    Position p=l->Next;
    while(!IsLast(p,l))
         {
           tmp=p;
           p=p->Next;
           free(tmp);
         }
         l->Next=NULL;
         free(p);
  }

  int IsEmpty(List l)
  {
     return l->Next==NULL;
  }

  int IsLast(Position p,List l)
  {
     Position pt=l->Next;
     while(pt!=p&&pt->Next!=NULL)
          pt=pt->Next;
     if(pt==p&&pt->Next==NULL)
       return 1;
     return 0;
  }

  Position Find(Element x,List l)
  {
     Position p=l->Next;
     while(p!=NULL&&p->Element!=x)
          p=p->Next;
     return p;
  }

  void Delete(Element x,List l)
  {
     Position p=FindPrevious(x,l);
     if(p!=NULL)
     {
        Position tmp=p->Next;
        p->Next=tmp->Next;
        free(tmp);
     }
  }

  Position FindPrevious(Element x,List l)
  {
    Position p=l->Next;
    while(p!=NULL&&p->Next->Element!=x)
        p=p->Next;
    return p;
  }

  void Insert(Element x,List l,Position p)
  {
    Position tmp=(Position)malloc(sizeof(List));
    if(tmp==NULL)
       {printf("Out of space !"); exit(1);}
    tmp->Element=x;
    tmp->Next=p->Next;
    p->Next=tmp;
  }

  void DeleteList(List l)
  {
    MakeEmpty(l);
    free(l);
  }

_飞寒 2010-12-20 21:06 发表评论

中缀-逆波兰变换

_飞寒 — Mon, 20 Dec 2010 13:05:00 GMT

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

#define DEBUG

struct Node;
typedef struct Node *ptr;
typedef ptr Stack;

struct Node
{
   char cha;
   ptr next;
       };

Stack CreatStack();
void Push(char,Stack);
void Pop(Stack);
char Top(Stack);
int IsEmpty(Stack);
void MakeEmpty(Stack);

int main()
{
    char cha;
    Stack s=CreatStack();
    while(scanf("%c",&cha)!=EOF)
    {
       if(cha=='\n')
       {
          while(!IsEmpty(s))
          {printf("%c",Top(s)); Pop(s);}
          continue;
       }  // 清栈
       else
       {
          if(cha!='+'&&cha!='*'&&cha!='-'&&cha!='/'&&cha!='('&&cha!=')')
             printf("%c",cha);
          else
          {
             if(cha=='(')
                Push(cha,s);
             else
                 if(cha==')')
                 {
                    while(Top(s)!='(')
                    {printf("%c",Top(s)); Pop(s);}
                    Pop(s);
                 }
                 else
                    if(cha=='*'||cha=='/')
                    {
                      while(!IsEmpty(s)&&Top(s)!='+'&&Top(s)!='-'&&Top(s)!='(')
                      {printf("%c",Top(s)); Pop(s);}
                      Push(cha,s);
                    }
                    else
                    {
                       while(!IsEmpty(s)&&Top(s)!='(')
                       {printf("%c",Top(s)); Pop(s);}
                       Push(cha,s);
                    }
          }
       }
    }
    system("pause");
    return 0;
}

_飞寒 2010-12-20 21:05 发表评论

"reverse_Polish", 计算器

_飞寒 — Mon, 20 Dec 2010 13:04:00 GMT

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

// #define DEBUG

struct Node;
typedef struct Node *point;
typedef point Stack;

struct Node
{
   int num;
   point next;
       } ;

Stack CreatStack();
void Push(int,Stack);
void Pop(Stack);
void MakeEmpty(Stack);
int IsEmpty(Stack);
int Top(Stack);

int main()
{
    char cha;
    int tmpNum1,tmpNum2;
    Stack s=CreatStack();
    while(scanf("%c",&cha)!=EOF)
    {
       if(cha=='\n') {printf("%d\n",Top(s)); MakeEmpty(s); continue;}
       if(cha>47&&cha<58)
          Push(cha%48,s);
       else
       {
          switch (cha)
          {
             case '+': tmpNum1=Top(s);
                       Pop(s);
                       tmpNum2=Top(s);
                       Pop(s);
                       Push(tmpNum2+tmpNum1,s);
                       #ifdef DEBUG
                           printf("%d\n",tmpNum2+tmpNum1);
                                         #endif
                        break;
             case '-': tmpNum1=Top(s);
                       Pop(s);
                       tmpNum2=Top(s);
                       Pop(s);
                       Push(tmpNum2-tmpNum1,s);
                       #ifdef DEBUG
                           printf("%d\n",tmpNum2-tmpNum1);
                                         #endif
                       break;
             case '*': tmpNum1=Top(s);
                       Pop(s);
                       tmpNum2=Top(s);
                       Pop(s);
                       Push(tmpNum2*tmpNum1,s);
                       #ifdef DEBUG
                           printf("%d\n",tmpNum2*tmpNum1);
                                         #endif
                       break;
             case '/': tmpNum1=Top(s);
                       Pop(s);
                       tmpNum2=Top(s);
                       Pop(s);
                       Push(tmpNum2/tmpNum1,s);
                       #ifdef DEBUG
                               printf("%d\n",tmpNum2/tmpNum1);
                                             #endif
                       break;
          }
       }
    }
    system("pause");
    return 0;
}

_飞寒 2010-12-20 21:04 发表评论

Stack_ADT

_飞寒 — Mon, 20 Dec 2010 12:58:00 GMT

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

#ifndef _Stack_h

struct Node;
typedef struct Node *PtyToNode;
typedef PtrToNode Stack;

int IsEmpty(Stack S);
Stack CreatStack(void);
void MakeEmpty(Stack S);
void Push(Element x, Stack s);
ElementType Top(Stack s);
void Pop(Stack s);

#endif

struct Node
{
  ElementType Element;
  PtrToNode Next;
       };

  int
  IsEmpty(Stack s)
  {
    return s->Next==NULL;
  }

  Stack
  CreatStack(void)
  {
     Stack s;
     s=(struct *)malloc(sizeof(struct Node));
     if(s==NULL)
        { printf("Out of Space !"); exit(1);}
     s->Next=NULL;
     MakeEmpty(s);
     return s;
  }

  void
  MakeEmpty(Stack s)
  {
    if(s==NULL)
       {printf("Must use CreatStack first !"); exit(1);}
    while(!IsEmpty(s))
         pop(s);
  }

  void
  Push(Element x,Stack s)
  {
     PtrToNode tmpcell=(Stack s)malloc(sizeof(Node));
     if(tmpcell==NULL)
        {printf("Out of space !"); exit(1);}
     tmpCall->Element=x;
     tmpCell->Next=s->Next;
     s->Next=tmpcell;
  }

  ElementType
  Top(Stack s)
  {
      if(IsEmpty(Stack s))
         {printf("Empty stack !"); exit(1);}
      return s->Next->Element;
  }

  void
  Pop(Stack s)
  {
    if(IsEmpty(Stack s))
       {printf("The stack is empty !"); exit(1);}
    Stack firstCell=s->Next;
    s->Next=s->Next->Next;
    free(firstCell);
  }

_飞寒 2010-12-20 20:58 发表评论

Polynomial_ADT

_飞寒 — Mon, 20 Dec 2010 12:56:00 GMT

#include<stdio.h>
#include<stdlib.h>
#define Maxdegree 999
struct Polynomial
{
  int CoeffArray[Maxdegree+1];
  int HighPower;
};

    void putin(struct Polynomial *);
    void putout(struct Polynomial *);
    int Maxhighpower(struct Polynomial *,struct Polynomial *);
    void ZeroPolynomial(struct Polynomial *);
    void Addpolynomial(struct Polynomial *,struct Polynomial *);
    void Subpolynomial(struct Polynomial *, struct Polynomial *);
    void Ridepolynomial(struct Polynomial *, struct Polynomial *);

int main()
{
    struct Polynomial poly1,poly2;
    int choose;
    printf("please type the coefficient of i like ,i is 0 to 999\n\n");
    printf("for poly1 stop by EOF\n");
    ZeroPolynomial(&poly1);
    putin(&poly1);
    printf("for poly2 stop by EOF\n");
    ZeroPolynomial(&poly2);
    putin(&poly2);
    printf("\nplease choose a operate:\n1.add\n2.subtract\n3.ride\n");
    scanf("%d",&choose);
    switch (choose)
    {
       case 1: Addpolynomial(&poly1,&poly2); break;
       case 2: Subpolynomial(&poly1,&poly2); break;
       case 3: Ridepolynomial(&poly1,&poly2); break;
    }
    system("pause");
    return 0;
}
void Addpolynomial(struct Polynomial *poly1,struct Polynomial *poly2)
{
   int step,highpower;
   struct Polynomial polysum;
   ZeroPolynomial(&polysum);
   highpower=Maxhighpower(poly1,poly2);
   polysum. HighPower=highpower;
   for(step=highpower;step>-1;step--)
     polysum. CoeffArray[step]=
        poly1->CoeffArray[step]+
        poly2->CoeffArray[step];
   putout(&polysum);
}
void Subpolynomial(struct Polynomial *poly1, struct Polynomial *poly2)
{
   int step,highpower;
   struct Polynomial polysum;
   ZeroPolynomial(&polysum);
   highpower=Maxhighpower(poly1,poly2);
   polysum. HighPower=highpower;
   for(step=highpower;step>-1;step--)
     polysum. CoeffArray[step]=
        poly1->CoeffArray[step]-
        poly2->CoeffArray[step];
   putout(&polysum);
}
void Ridepolynomial(struct Polynomial *poly1,struct Polynomial *poly2)
{
   int step1,step2,highpower;
   struct Polynomial polysum;
   ZeroPolynomial(&polysum);
   polysum.HighPower=poly1->HighPower+poly2->HighPower;
   if(polysum.HighPower>Maxdegree)
     printf("Exceeded array size!\n");
   else
   {
     for(step1=0;step1<poly1->HighPower+1;step1++)
        for(step2=0;step2<poly2->HighPower+1;step2++)
           polysum.CoeffArray[step1+step2]+=
                    poly1->CoeffArray[step1]*
                    poly2->CoeffArray[step2];
     putout(&polysum);
   }
}
int Maxhighpower(struct Polynomial *poly1,struct Polynomial *poly2)
{
   if(poly1->HighPower>poly2->HighPower)
      return poly1->HighPower;
   else
      return poly2->HighPower;
}
void ZeroPolynomial(struct Polynomial *poly)
{
   int step;
   for(step=Maxdegree;step>-1;step--)
        poly->CoeffArray[step]=0;
}
void putin(struct Polynomial *poly)
{
     int i,a;
     poly->HighPower=0;
     while(scanf("%d%d",&i,&a)!=EOF)
     {
       poly->CoeffArray[i]=a;
       if(poly->HighPower<i)
          poly->HighPower=i;
     }
}
void putout(struct Polynomial *polyresult)
{
   int i;
   printf("Result is :\n");
   for(i=polyresult->HighPower;i>-1;i--)
      if(polyresult->CoeffArray[i]!=0)
         printf("%d : %d\n",i,polyresult->CoeffArray[i]);
}

_飞寒 2010-12-20 20:56 发表评论