1.回文问题.正读和反读相同的字符串称之为"回文",写一个算法判断从键盘上输入的字符串是否是"回文",要求用栈和队列做,输入用栈做,输出用队列做,并在TC2.0中调试成功. 2.置换问题.在一个字符串中,查找并替换.eg:S=anhdanjsavaan,T=an,M=abs.先在S中查找T,再把T替换成M.可以用堆做.并在TC2.0中调试成功.

AD:乙醇气体检测仪、探测器、报警器

平衡化旋转的关键在于旋转以后仍然是一棵AVL树.

有四种:若右重,则左单旋, 若左重,则右单旋

有时,有先左后右双旋转,有时,有先右后左双旋转

[em03][em06]

排序分类	排序法	原理	时间复杂度	空间复杂度	稳定性
插入排序	直接插入排序 折半插入排序 链表插入排序 希尔排序
交换排序	起泡排序 快速排序
选择排序	直接选择排序 锦标赛排序 堆排序
归并排序	迭代的归并 递归的归并
基数排序

#include<iostream.h>

class RecurveArray {

private:

int *Elements; int ArraySize; int CurrentSize;

public: int MaxSize; RecurveArray(int MaxSize=10):ArraySize(MaxSize),Elements(new int [MaxSize]){}; ~RecurveArray() {delete[]Elements;}

void InputArray(); int MaxKey(int n); int Sum(int n); float Average(int n);

};

void RecurveArray::InputArray() { cout<<"Input the number of Array:\n"; for (int i=0;i<ArraySize;i++) { cin>>Elements;} }

int RecurveArray::MaxKey(int n) { if (n==1) return Elements[0]; int temp=MaxKey(n-1); if(Elements[n-1]>temp)return Elements[n-1]; else return temp; }

int RecurveArray::Sum(int n){ if(n==1)return Elements[0]; else return Elements[n-1]+Sum(n-1); }

float RecurveArray::Average(int n){ if (n==1)return (float) Elements[0]; else return((float) Elements[n-1]+(n-1)*Average(n-1))/n; }

int main(int argc,char *argv[]) { int size=0; cout<<"No.of the Elements:\n"; cin >>size; cout<<"the size is :"<<size; RecurveArray ra(size); ra.InputArray(); cout<<"it's ok\n"; cout<<"\nThe max is :"<<ra.MaxKey(size)<<endl; cout<<"\nThe sum is :"<<ra.Sum(size)<<endl; cout<<"\nThe avr is :"<<ra.Average(size)<<endl; }

[em06][em06]

[此贴子已经被作者于2004-8-7 21:15:12编辑过]

什么时候一起讨论一下啊上面的gg！

[em06]

good!

AOE网络:用边表示活动

用顶点表事件,用边表活动

完成不同路径的活动所需的时间虽然不同,但只有各条路径上所有活动都完成了,整个工程才算完成.

因此,完成整个工程所需的时间取决于从源点到汇点的最长的路径长度,即在这条路径上所有活动的待续时间之和.这条路径长度最长的路径就叫做Critical Path.

[em01]

#ifndef ARRAY_CLASS

#define ARRAY_CLASS

#include <iostream.h> #include <stdlib.h>

#ifndef NULL const int NULL=0; #endif//NULL

enum ErrorType {invalidArraySize,memoryAllocationError,indexOutOfRange};

char *errorMsg[]= { "Invalid array size","Memory allocation error", "Invalid index:" };

template <class T> class Array { private: T *alist; int size; void Error(ErrorType error,int badIndex=0) const;

public:

Array(int sz=50); Array(const Array<T>&A); ~Array(void); Array<T>&operator=(const Array<T> &rhs); T& operator[](int i); operator T*(void) const; int ListSize(void) const; void Resize(int sz); };

template <class T> void Array<T>::Error(ErrorType error,int badIndex)const { cout<<errorMsg[error];

if(error == indexOutOfRange)cout<<badIndex; cout<<endl; exit(1); }

template<class T> Array<T>::Array(int sz) { if(sz<=0)Error(invalidArraySize); size=sz; alist=new T[size]; if(alist==NULL) Error(memoryAllocationError); }

template <class T> Array<T>::~Array(void) {delete[]alist;}

template <class T> Array <T>::Array(const Array<T> &X) { int n=X.Size; size=n; alist=new T[n]; if(alist==NULL) Error(memoryAllocationError); T *srcptr=X.alist; T *destptr=alist; while(n--) *destptr++=*srcptr++; } template <class T> Array <T> &Array<T>:perator=(const Array<T> &rhs) { int n=rhs.size; if(size!=n) { delete[]alist; alist=new T[n]; if(alist==NULL) Error(memoryAllocationError); size=n; } T *destptr=alist; T *srcptr=rhs.alist; while(n--) *desptr++=*srcptr++; return *this; } template<class T> T &Array<T>:perator[] (int n) { if(n<0||n>size-1) Error(indexOutOfRange,n); return alist[n]; } template <class T> Array<T>:perator T*(void)const { return alist; } template <class T> int Array <T>:istSize(void)const { return size; } template <class T> void Array <T>::Resize(int sz) { if(sz<=0) Error(invalidArraySize); if (sz==size) return;

T*newlist=new T[sz]; if(newlist==NULL) Error(memoryAllocationError); int n=(sz<=size)? sz:size; T *srcptr=alist; T *destptr=newlist; while(n--) *destptr++= *srcptr++; delete[]alist; alist=newlist; size=sz; } #endif//ARRAY_CLASS

#include <iostream.h> #include<iomanip.h> #include"array_1.h"

void main(void) { Array <int> A(10); int n; int primecount=0,i,j; cout<<"Enter a value>=2 as upper limit for prime numbers:"; cin>>n;

A[primecount++]=2;

for(i=3;i<n;i++) { if(primecount==A.ListSize())A.Resize(primecount+10); if (i%2==0) continue; j=3; while(j<=i/2&&i%j!=0) j+=2; if(j>i/2) A[primecount++]=i; }

for (i=0;i<primecount;i++) { cout<<setw(5)<<A; if((i+1)%10==0) cout<<endl; } cout<<endl; }

由于栈也是一种线性群体,因此栈的数据可以用数组或链表来存储.但是对栈中元素的访问是受限制的,压入栈和弹出栈的操作都只能在栈顶进行,因此不宜直接用数组类和链表类来解决栈的问题,而是需要专门设计类.