数据结构期末考试复习--3

waitwolf

2020-01-06

删除 L 中所有值为 item 的元素

void  Delete_e(SqList &L,ElemType e)
{int i=0,j=L.length-1;//设置数组低、高端指针（下标）。
 while(i<j)
   { while(i<j&&L.elem[i]!=e)i++; //若值不为e，右移指针。
     while(i<j&&L.elem[j]==e){ j--; // L.length--;
            }//若右端元素为item，指针左移
     if(i<=j){L.elem[i++]=L.elem[j--];   //L.length--;
                         }
 L.length=i-1;
 }
}

将数组中所有正数排在所有负数的前面

void Arrange(int A[],int n)
//n个整数存于数组A中，本算法
 {int i=0,j=n-1,x;  //数组下标从0开始
  while(i<j)
  {while(i<j && A[i]>0)  i++;
   while(i<j && A[j]<0)  j--;
   if(i<j) {x=A[i]; A[i++]=A[j]; A[j--]=x; }
                                                 //交换A[i] 与A[j]  }
     }//算法Arrange结束.

双冒泡

void DoubleBubbleSort(KeyType R[],int n)
{    int i,low=0,high=n-1;
     KeyType temp;
    bool exchange;
    while(low<high)
    { exchange=false;
        //从前往后进行一次冒泡排序，将最大的值放在最后一个位置
        for(i=low;i<high;++i)
          {
           if(R[i]>R[i+1]) //如果前面的值比后面的值大，发生交换
               {  temp=R[i];  R[i]=R[i+1]; R[i+1]=temp;
                   exchange=true;
               }
           }
           //从后往前进行一次冒泡排序，将最小的值放在第一个位置
        for(i=high-1;i>low;--i)
        {  if(R[i]<R[i-1]) //如果后面的值比前面的值小，发生交换
            {
                temp=R[i];    R[i]=R[i-1];  R[i-1]=temp;
                exchange=true;
            }
        }
        if(!exchange)   //本趟没有发生交换，提前终止
            return;
               ++low; //更新上下边界
             --high;
    }
}

求链表的最大数

Status  Maxelem_L(LinkList L,int &max)
{  if (L->next==NULL) return error
   else
     { LNode *p=L->next;
       max=p->data;       p=p->next;
       while(p)
        {  if(p->data>max)      max=p->data;
            p=p->next;
          }
    }
  return  ok;
}

递归方法求链表的最大数

int GetMax(LinkList p)
{
    if(!p->next)
        return p->data;
    else
    {
        int max=GetMax(p->next);
        return p->data>=max ? p->data:max;
    }
}

利用栈数值转换算法

void conversion ( int N,int k) {
    initstack ( S );
    while ( N ) {
            push (S，N%k);
            N = N / k;
            }
        while ( ! Stackempty(s) ){
            pop ( S,e );
                if(e<=9)
                    cout<<e;
                else
                    cout<<char(e+55);
}
           }//conversion
}

递归方法实现进制转换

void conversion(int n)
{
    if(n==0)    return ;
    else
    {
        conversion(n/8);
        cout<<n%8;
                      }
}

在有序表 ST 中折半查找

int Search_Bin(SSTable ST,KeyType key,int low,int high)
 {
  if(low<=high)
   {     mid=(low+high)/2;
     if (key=ST.elem[mid].key)  // 找到待查元素
            return mid;
     else if LT(key,ST.elem[mid].key)
           return Search_Bin( ST, key,low,mid-1);
     else
       return   Search_Bin( ST, key,mid+1,high);   }
else return 0; // 顺序表中不存在待查元素
 }

二叉排序树查找

BSTree Searchlev(BSTree T,char key,int &lev) {
  //在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元素
  //若查找成功，则返回指向该数据元素结点的指针和层次，否则返回空指针
  if(T)
     { lev++;
      if( key==T->data.key) return T;               //查找结束
      else if (key<T->data.key)
          return Searchlev(T->lchild,key,lev);  //在左子树中继续查找
      else  return Searchlev(T->rchild,key,lev);   //在右子树中继续查找
    }
else   return T;
}

二叉排序树查找非递归

BSTree Searchlev(BSTree T,int key,int &lev){
    BSTree p=T;
    while(p){
         ++lev;
        if (key==p->data.key)    return  p;
        else if (key<p->data.key)
                p=p->lchild;     //在左子树中继续查找
        else   p=p->rchild;     //在右子树中继续查找
            }
        return   p;
     }

统计输入字符串中数字字符和字母字符的个数

void count()
{ int i,num[36];  char ch;
  for (i=0;i<36;i++) num[i]=0;
  while ((ch=getchar())!='#')
  {  if('0'<=ch&&ch<='9')
      {   i=int(ch)-48; num[i]++;}
     else if('A'<=ch&&ch<='Z')
      {i=ch-65+10;  num[i]++;}
    }
  for(i=0;i<10;i++)
      cout<<"数字"<<i<<"的个数"<<num[i]<<endl;
  for(i=10;i<36;i++)
    cout<<"字母"<<char(i+55)<<"的个数"<<num[i]<<endl;
}

统计串 S 中字符的种类和个数

void StrAnalyze(SString S)//统计串S中字符的种类和个数
{char c;   mytype T[20]; //用结构数组T存储统计结果
 int i,j;
 for (i=0;i<=20;i++) T[i].ch='\0';
  for(i=1;i<=S.length;i++)
  {    c=S[i];j=0;
    while(T[j].ch&&T[j].ch!=c)  j++; //查找当前字符c是否已记录过
    if(T[j].ch)   T[j].num++;
    else { T[j].ch=c;T[j].num++;}
  }//for
  for(j=0;T[j].ch;j++)
   cout<<T[j].ch<<":"<<T[j].num<<endl;
}//StrAnalyze

应用二叉排序树分类统计

void CreaTree(BTree &p,char c) //采用递归方式构造一棵二叉排序树
{   if (p==NULL)    //p为NULL,则建立一个新结点
    {
        p=new tnode;
        p->ch=c;
        p->count=1;
        p->lchild=p->rchild=NULL;
    }
    else if (c==p->ch) 
        p->count++;
    else if (c<p->ch) 
        CreaTree(p->lchild,c);
    else 
        CreaTree(p->rchild,c);
}

链表的调整-逆置带头结点的单链表

void  inverse(LinkList &L) {
    // 逆置带头结点的单链表 L
    p=L->next;  L->next=NULL;
    while ( p) {
        q=p->next;    // q指向*p的后继
        p->next=L->next;
        L->next=p;       // *p插入在头结点之后
        p = q;
    }
}

链表选择排序

void LinkedListSelectSort(LinkedList head)
 //本算法一趟找出一个关键字最小的结点，其数据和当前结点进行交换; 
//若要交换指针，则须记下当前结点和最小结点的前驱指针
  p=head->next; 
  while(p!=NULL)
    {
        q=p->next; r->data=p->data;    //设r是指向关键字最小的结点的指针
     while (q!=NULL)
      {
          if(q->data<r->data) r->data=q->data;
          q=q->next;
    }
     if(r!=p)  r->data<-->p->data;//这里表示交换这两个节点
            p=p->next;
    }

算法与数据结构数据结构 return h2