数据结构使用教程 代码

//2.4-2,3,5
//get max value in linked list
ElemType MaxValue(LNode * head)
{
  if(head==NULL)
  {
      cerr<<"Linked list is empty!"<<endl;
      exit(1);
  }
  ElemType max=head->data;
  LNode* p=head->next;//用temp指针p指向链表
  while(p!=NULL)
  {
     if(p->data>max)
         max=p->data;
     p=p->next; //指向下一个指针
  }
  return max;
}

//
int Count(LNode* head,ElemType x)
{
  int n=0;
  while(head!=NULL)
  {
      if(head->data==x)
          n++;
      head=head->next;
  }
  return n;
}

LNode* Merge(LNode* &p1,LNode* &p2)
{
    LNode a; //便于处理，创建结果有序表头附加节点，
    LNode* p=&a;//p指向结果链表的表尾节点，初始指向表头附加节点
    p->next=NULL;
    while(p1!=NULL&&p2!=NULL)
    {
        if(p1->data<=p2->data)
        {
            p->next=p1;
            p1=p1->next;
        }else{
            p->next=p2;
            p2=p2->next;
        }
        p=p->next;
    }

    if(p1!=NULL) p->next=p1;
    if(p2!=NULL) p->next=p2;

    p1=p2=NULL;
    return a.next;
}

template<class ElemType>
class Stack{
    ElemType *stack;
    int top;
    int MaxSize;
public:
    Stack();
    Stack(Stack& s);
    Stack& operator=(Stack& s);
    void Push(ElemType item);
    ElemType Pop();
    ElemType Peek();
    bool EmptyStack();
    ~Stack();
};

template<class ElemType>
ElemType Stack<ElemType>::Pop()
{
    ///write something
}

template<class ElemType>
ElemType Stack<ElemType>::Peek()
{
    ///write something
}

template<class ElemType>
void Stack<ElemType>::Push(ElemType item)
{
    ///write something
}

template<class ElemType>
bool Stack<ElemType>::EmptyStack()
{
    return top==-1;
}
//4.3 -2,3
//后缀表达式的求值定义 ，操作数栈为引用参数
double Compute(Stack<double> &S,char* str)
{
  double x,y;// 保存浮点数
  int i=0;
  while(str[i]){
      if(str[i]=='')
      {
          i++;continue;
      }
      switch(str[i]){
       case '+':
           x=S.Pop()+S.Pop();
           i++;
           break;
       case '-':
           x=S.Pop();
           x=S.Pop()-x;
           i++;
           break;
       case '*':
           x=S.Pop()*S.Pop();
           i++;
           break;
       case '/':
           x=S.Pop();
         if(x!=0.0) x=S.Pop()/x;
         else
         {
            cerr<<"Divide by zero!"<<endl;
            exit(1);
         }
         i++;
         break;
       default:
           x=0;
           while(str[i]>=48&&str[i]<=57){
              x=x*10+str[i]-48;i++;
           }
           if(str[i]=='.'){
               i++;
               y=0;
               double j=10.0;
               while(str[i]>=48&&str[i]<=57){
                   y=y+(str[i]-48)/j;
                   i++;j*=10;
               }
               x+=y;
           }
      }
      S.Push(x);
  }
  if(S.EmptyStack())
  {
      cerr<<"Stack is empty!"<<endl;
      exit(1);
  }
  x=S.Pop();
  if(S.EmptyStack()) return x;
  else
  {
      cerr<<"expression error!"<<endl;
      exit(1);
  }
}

//返回运算符op的优先级数值
int Precedence(char op)
{
   switch(op)
   {
     case '+':
     case '-':
         return 1;
     case '*':
     case '/':
         return 2;
     case '(':
     case '@':
     default:
         return 0;
   }
}

//中缀表达式转换成后缀表达式 运算符栈为引用参数
void Change(Stack<char>& R,char* s1,char* s2)
{
   R.Push('@');
   int i=0,j=0;
   char ch=s1[i];
   while(ch!='\0')
   {
       if(ch=='') ch=s1[++i];
       else if(ch=='('){
           R.Push(ch);ch=s1[++i];
       }
       else if(ch==')'){
           while(R.Peek()!='(') {s2[j++]=R.Pop();}
           R.Pop(); // 删除站顶的左括号
           ch=s1[++i];
       }
       else if(ch=='+'||ch=='-'||ch=='*'||ch=='/'){

           char w=R.Peek();
           while(Precedence(w)>=Precedence(ch))
           {
               s2[j++]=w;R.Pop();
               w=R.Peek();
           }
           R.Push(ch);
           ch=s1[++i];
       } else{
           if((ch<'0'||ch>'9')&&ch!='.'){
               cout<<"error"<<endl;
               exit(1);
           }
           while((ch<'0'||ch>'9')&&ch!='.'){
               s2[j++]=ch;
               ch=s1[++i];
           }
           s2[j++]='';
       }

       ch=R.Pop();
       while(ch!='@'){
           if(ch=='(')
           {
               cerr<<"expression error"<<endl;exit(1);
           }else{
               s2[j++]=ch;
               ch=R.Pop();
           }
       }
       s2[j++]='\0';
   }
}

//利用辗转相除和递归的方法求两个整数的最大公约数
int f1(int a,int b)
{
  //cout<<"a="<<a<<","<<"b="<<b<<endl;
  if(a%b==0) return b;
  else return f1(b,a%b);
}

//Fibonacci 数列递归和非递归算法
int Fib(int n)
{
    if(n==1||n==2) return n-1; //终止递归条件
    else return Fib(n-1)+Fib(n-2);
}
//时间复杂度O(2*n) 空间复杂度O(n)

int Fib2(int n)
{
    int a,b,c;
    a=0;b=1;
    if(n==1||n==2) return n-1;
    else
    {
        for(int i=3;i<=n;i++)
        {
            c=a+b;
            a=b;
            b=c;
        }
        return c;
    }
}
//时间复杂度O(n) 空间复杂度O(1)

//编写汉诺塔问题的非递归算法
void Hanoi1(int n,int a,int b,int c)
{
  struct items{
      int n,a,b,c;
  };
  items s[10]; //used for sequence stack
  int top=-1;
  items temp;
  while(top!=-1||n>=1)
  {
     while(1){
         if(n==1) {cout<<a<<"=>"<<c<<endl;n=0;break;}
         temp.n=n;temp.a=a;temp.b=b;temp.c=c;
         top++;s[top]=temp; //enter stack
         cout<<"n1="<<n<<endl;
         n=n-1;int d=b;b=c;c=d;//a's value no change
         cout<<"n2="<<n<<endl;
     }
     if(top!=-1){
       temp=s[top];top--;
       n=temp.n;a=temp.a;b=temp.b;c=temp.c;
       cout<<a<<"->"<<c<<endl;
       n=n-1;int d=a;a=b;b=d;//c's value no change
     }
  }
}

struct BTreeNode{
    ElemType data;
    BTreeNode* left;
    BTreeNode* right;
};

// binary tree node count
int BTreeNodeCount(BTreeNode* BT)
{
  if(BT==NULL) return 0;
  else
      return BTreeNodeCount(BT->left)+BTreeNodeCount(BT->right)+1;
}

// binary tree leaf count
int BTreeLeafCount(BTreeNode* BT)
{
   if(BT==NULL) return 0;
   else if(BT->left==NULL&&BT->right==NULL) return 1;
   else return BTreeLeafCount(BT->left)+BTreeLeafCount(BT->right);
}