稀疏矩阵

by admin on 2020年1月20日

void Init(int rcount,int ccount)
{
    int i,j,counter=0,temp;
    TSMatrix Storage,Transposition;
    srand((unsigned)time(NULL));
    printf(“The original matrix is:n”);
    for(i=1;i<=rcount;i++)
    {
        for(j=1;j<=ccount;j++)
        {
            if(0==rand()%2) printf(“%dt”,0);
            else if(0==(i*ccount+j)%2) printf(“%dt”,0);
            else
            {
                temp=rand()%2+rand()%9;
                printf(“%dt”,temp);
                Storage.data[++counter].elem=temp;
                Storage.data[counter].i=i;
                Storage.data[counter].j=j;
            }
        }
        printf(“n”);
    }
    printf(“nn”);
    Storage.ccount=ccount;
    Storage.rcount=rcount;
    Storage.counter=counter;
    printf(“The triple of the original matrix
is:n”);
    Display(Storage);
    printf(“*****************nnn”);
    Transpose(Storage,Transposition);
}//发轫化荒凉矩阵并打字与印刷

}澳门新葡亰平台官网 1

澳门新葡亰平台官网 2程序代码:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAXSIZE 100
#define ELEMTYPE int
typedef struct
{
    int i,j;
    ELEMTYPE elem;
}Triple;
typedef struct
{
    Triple data[MAXSIZE+1];
    int rcount,ccount,counter;
}TSMatrix;

}
return ok;
}
void main()
{
int i,j,c,r;
int a[10][10];
printf(“请输入矩阵行数和列数n”);
scanf(“%d %d”,&r,&c);
printf(“请输入矩阵n”);
for(i=1;i<=r;i++)
{
for(j=1;j<=c;j++)
{
scanf(“%d”,&a[i][j]);
}
}
TSMatrix M,T;

学业贴5:多项式的相乘
例程:

void main()
{
    int rcount,ccount;
    scanf(“%d %d”,&rcount,&ccount);
    Init(rcount,ccount);
}

int x=1,b[c][r];for(i=1;i<=c;i++) for(j=1;j<=r;j++) { if(T.data[x].i==i&&T.data[x].j==j) { b[i][j]=T.data[x].e; x++; } else b[i][j]; }for(i=1;i<=r;i++){for(j=1;j<=c;j++)printf("%d",b[i][j]);printf;}

学业贴2:线索二叉树的中序线索化及其遍历
例程:

void Transpose(TSMatrix M,TSMatrix
N)
{
    N.rcount=M.ccount;
    N.ccount=M.rcount;
    N.counter=M.counter;
    int p,temp,q=1;
    for(temp=1;temp<=M.ccount;temp++)
    {
        for(p=1;p<=M.counter;p++)
        {
            if(M.data[p].j==temp)
            {
                N.data[q].i=M.data[p].j;
                N.data[q].j=M.data[p].i;
                N.data[q].elem=M.data[p].elem;
                q++;
            }
        }//置换并列排在一条线序
    }
    printf(“The transposed triple of the original one
is:n”);
    Display(N);
    printf(“*****************nnn”);
    printf(“The transposed matrix of the original one
is:n”);
    int x;
    int tempr[MAXSIZE]={0},tempc[MAXSIZE]={0};
    for(x=1;x<=N.counter;x++)
    {
        if(N.data[x].elem)
            tempr[x]=N.data[x].i;
            tempc[x]=N.data[x].j;
    }
    x=1;
    int s,t;
    for(s=1;s<=N.rcount;s++)
    {
        for(t=1;t<=N.ccount;t++)
        {
            if(tempr[x]==s&&tempc[x]==t)
            {
                printf(“%dt”,N.data[x].elem);
                x++;
            }
            else printf(“%dt”,0);
        }
        printf(“n”);
    }
}//安慕希组逆序并出口并依靠逆序后的安慕希组逆序输出荒芜矩阵

伊利组法求矩阵的转置,并出口转置矩阵,现身如图的荒谬,为啥啊?求大神指引迷津
#include
//#include
#define MAXSIZE 12500
#define ok 1
typedef int ElemType;
typedef int status;
typedef struct {
int ru,cu;
澳门新葡亰平台官网,ElemType e;
}Triple ;
typedef struct {
Triple data[MAXSIZE+1];
int m,n,t;
}TSMatrix;
status Transpose(TSMatrix M,TSMatrix T){
int q,col,p;
T.m=M.n;T.n=M.m;T.t=M.t;
if{
q=1;
for(col=1;col<=M.n;col++)
{
for(p=1;p<=M.m;p++)
{
if(M.data[p].cu==col){
T.data[q].ru=M.data[p].cu;
T.data[q].cu=M.data[p].ru;
T.data[q].e=M.data[p].e;
q++;
}
}

#include <stdio.h>//测试值:abc@@de@g@@f@@@
#include <stdlib.h>
#define Link 0
#define Thread 1
typedef char TElemType;
typedef struct BiThrNode
{
    TElemType data;
    struct BiThrNode *lchild,*rchild;
    int LTag,RTag;
}BiThrNode,*BiThrTree;
////////
BiThrTree pre;//全局变量
////////
BiThrTree CreatBiThrTree(卡塔尔(قطر‎;//先序创立二叉树
void InThreading(BiThrTree p卡塔尔;//中序遍历二叉树
void InOrderThreading(BiThrTree *Thrt,BiThrTree T卡塔尔;//中
序线索化二叉树
void Visit(char c);
void InorderTraverse_Thr(BiThrTree T卡塔尔国;//中序遍历二叉树
void main()
{
    BiThrTree t;
    BiThrTree thrtnode=NULL;
    printf(“请按先序遍历种类输
入二叉树中逐生机勃勃结点的值(字符卡塔尔(قطر‎,若为空树时输入空格键:n”);
    printf(“<表达:比方参谋数据为:abc@@de@g@@f@@@,则用空格键表示@,输完后再输入叁个回车键.>n”);
    t=CreatBiThrTree();
    printf(“中序线索化二叉 树:n”);
    InOrderThreading(&thrtnode,t);
    printf(“线索化职业已经完 成!n”);
    printf(“中序遍历线索二叉 树:n”);
    InorderTraverse_Thr(thrtnode);
}
BiThrTree CreatBiThrTree(卡塔尔(قطر‎//先序创造二叉树
{
    TElemType ch;
    BiThrTree T;
    scanf(“%c”,&ch);
    if(ch==’ ‘)
        T=NULL;
    else
    {
        T=(BiThrTree)malloc(sizeof(BiThrNode));
        if(!T)
            exit(0);
        T->data=ch;
        T->LTag=Link;
        T->RTag=Link;
        T->lchild=CreatBiThrTree();
        T->rchild=CreatBiThrTree();
    }
    return T;
}
void InThreading(BiThrTree p卡塔尔(قطر‎//中序遍历二叉树
{
    if(p)
    {
        InThreading(p->lchild卡塔尔(قطر‎;//左子树线索化
        if(!p->lchild卡塔尔(قطر‎//后驱线索
        {
            p->LTag=Thread;
            p->lchild=pre;
        }
        if(!pre->rchildState of Qatar//后继线索
        {
            pre->RTag=Thread;
            pre->rchild=p;
        }
        pre=p;//保持pre 指向p的前驱
        InThreading(p->rchild卡塔尔;//右子树线索化
    }
}
void InOrderThreading(BiThrTree *Thrt,BiThrTree T卡塔尔(قطر‎//中 序线索化二叉树
{
    if(!((*Thrt)=(BiThrTree)malloc(sizeof(BiThrNode))))
  exit(0);
    (*Thrt)->LTag=Link;
    (*Thrt)->RTag=Thread;
    (*Thrt)->rchild=(*Thrt);
    if(!T)
        (*Thrt)->lchild=(*Thrt);
    else
    {
        (*Thrt)->lchild=T;
        pre=(*Thrt);
        InThreading(T卡塔尔;//中序遍历举行中序线索化
        pre->rchild=(*ThrtState of Qatar;//最终三个结点线索化
        pre->RTag=Thread;
        (*Thrt)->rchild=pre;
    }
}
void Visit(char c)
{
    printf(” %c “,c);
}
void InorderTraverse_Thr(BiThrTree T卡塔尔//中序遍历二叉树
{
    BiThrTree p;
    p=T->lchild;
    while(p!=T卡塔尔(قطر‎//空树或遍历甘休时,p=T
    {
        while(p->LTag==Link)
            p=p->lchild;
        Visit(p->dataState of Qatar;//访谈左子树为空的结点
        while(p->RTag==Thread&&p->rchild!=T卡塔尔国//访谈后继结点
        {
            p=p->rchild;
            Visit(p->data);
        }
        p=p->rchild;
    }
}

void Display(TSMatrix M)
{
    int temp;
    printf(“*****************n”);
    printf(“itjtvn”);
    printf(“*****************n”);
    for(temp=1;temp<=M.counter;temp++)
    {
        if(M.data[temp].elem)
        {
            printf(“%dt%dt%dn”,M.data[temp].i,M.data[temp].j,M.data[temp].elem);
        }
    }
}//打字与印刷伊利组

M.m=r;M.n=c;M.t=1;
for(i=1;i<=r;i++)
{
for(j=1;j<=c;j++)
{
if
{
M.data[M.t].ru=i;
M.data[M.t].cu=j;
M.data[M.t].e=a[i][j];
M.t++;
}
}
}
Transpose;

  }
}
OutPutSMatrix_OL(M);
return true;
}
int main()
{
    cout.fill(‘*’);
cout<<setw(80)<<‘*’;
cout.fill(‘ ‘);
// system(“color 0C”);
cout<<setw(50)<<“***应接使用矩阵运算程序***”<<endl;                    //输出头菜单
cout.fill(‘*’);
cout<<setw(80)<<‘*’;
cout.fill(‘ ‘);
cout<<“请选取要举办的操作:”<<endl;
cout<<“1:矩阵的转置。”<<endl;
cout<<“2:矩阵的加(减)法。”<<endl;
cout<<“3:矩阵的乘法。”<<endl;
cout<<“4:推出程序。”<<endl;
char c=getchar();
if(c==’1′)
  TransposeSMatrix( State of Qatar;     //调用矩阵转置函数
else
  if(c==’2′)
   AddSMatrix(卡塔尔国;        //调用矩阵相加函数
  else
   if(c==’3′)
    MultSMatrix (卡塔尔(قطر‎;  //调用矩阵相乘函数
   else
    exit(0);         //退出
return 0;
}

//疏落矩阵

/*测量检验实例:
Input:
2 1 3 2 0 0
Output:
f(x)=2x+3x^2
Input:
1 1 1 0 0 0
Output:
f(x)=x+1
Output:
The Result is :
f(x)=x+5x^2+3x^3
*/
#include <iostream>
using namespace std;
struct list
{
int coef; //系数
int exp; //指数
list *next;
};
list *Creat(卡塔尔(قطر‎; //创造带头 结点的链表
void Display(list *h卡塔尔国; //输出链表
list *Merge(list *h1卡塔尔; //归并同类项
list *Multiply(list *h1,list *h2卡塔尔(قطر‎; //完成五个链表相乘
int main()
{
list *h1,*h2;
h1=Creat();
Display(h1);
h2=Creat();
Display(h2);
cout<<“The Result is:”<<endl;
h1=Multiply(h1,h2);
Display(h1);
return 0;
}
list *Creat(State of Qatar//创立起头结点 的链表
{
list *h,*r,*s;//h是头结 点,存放项的个数,指向第风华正茂项
r=h=new list;
h->next=NULL;
while(1)
{
  s=new list;
  cin>>s->coef>>s->exp;
  if(s->coef==0 )
   break;
  if(h->next==NULL)
  {
   r=s;//r=h->next
   h->next=r;
  }
  else
  {
   r->next=s;
   r=s;
  }
  r->next=NULL;
}
return h;
}
void Display(list *h卡塔尔国//输出链表
{
list *p;
p=h->next;
cout<<“f(x)=”;
while(p)
{
  if(p->next!=NULL)
  {
   switch (p->exp)
   {
   case 0:
    cout<<p->coef<<“+”;
    break;
   case 1:
    cout<<“X”<<“+”;
    break;
   default:
    cout<<p->coef<<“X^”<<p->exp<<“+”;
   }
  }
  else
  {
   switch (p->exp)
   {
   case 0:
    cout<<p->coef;
    break;
   case 1:
    cout<<“X”;
    break;
   default:
    cout<<p->coef<<“X^”<<p->exp;
   }
  }
  p=p->next;
}
cout<<endl;
}
list *Merge(list *h1卡塔尔(قطر‎//合併同类项
{
list *p1,*q1,*q2;
    for(p1=h1->next;p1;p1=p1->next)
{
  for(q1=p1,q2=q1->next;q2;q1=q2,q2=q2->next)
  {
   if(p1->exp==q2->exp)
   {
    p1->coef+=q2->coef;
    q1->next=q2->next;
    delete q2;
    q2=q1;//q2=q1->next;
   }
  }
}
//sort
struct list *temp, *cur, *pre, *preindex, *curindex;
for(pre=h1->next, cur=h1->next->next; cur !=NULL; pre=cur,
cur=cur->next)
{
  preindex=h1;
  curindex=h1->next;
  while (curindex != cur )
  {
   if (curindex->exp > cur->exp)
   {
    temp=cur;
    cur=cur->next;
    pre->next=cur;
    temp->next=curindex;
    preindex->next=temp;
    break;
   }
   preindex=curindex;
   curindex=curindex->next;
  }
}
return h1;
}
list *Multiply(list *h1,list

#include <iostream>
#include <iomanip>
using namespace std;
const int MAXSIZE=100;    // 定义非零成分的对多少个数
const int MAXROW=10; // 定义数组的行数的最大值
typedef struct
{          // 定义莫斯利安组的要素
int i,j;
int e;
} Triple;
typedef struct
{         // 定义普通莫斯利安组对象
Triple data[MAXSIZE+1];
int mu,nu,tu;
} TSMatrix;
typedef struct
{       // 定义带链接新闻的伊利组对象
Triple data[MAXSIZE+2];
int rpos[MAXROW+1];
int mu,nu,tu;
} RLSMatrix;
typedef struct OLNode
{   // 定义十字链表成分
int i,j;
int e;
struct OLNode *right,*down;  //  该非零元所在行表和列表的后继成分
}OLNode,*OLink;
typedef struct
{            //   定义十 字链表对象构造体
OLink *rhead,*chead;   
int mu,nu,tu;          //   全面矩阵的行数,列数,和非零成分个数
}CrossList;
template <class P>
bool InPutTSMatrix(P & T,int y)
{     //输入矩阵,按安慕希组格式输入
cout<<“输入矩阵的行,列和非零成分个数:”<<endl;
cin>>T.mu>>T.nu>>T.tu;
cout<<“请输出非零成分的任务和值(从1上马记卡塔尔:”<<endl;
int k=1;
for(;k<=T.tu;k++)
  cin>>T.data[k].i>>T.data[k].j>>T.data[k].e;
return true;
}
template <class P>
bool OutPutSMatrix(P T)
{       // 输出矩阵,按规范格式输出
int m,n,k=1;
for(m=0;m<T.mu;m++)
{
  for(n=0;n<T.nu;n++)
  {
   if((T.data[k].i-1)==m&&(T.data[k].j-1)==n)
   {
                cout.width(4);
    cout<<T.data[k++].e;
   }
   else
   {
    cout.width(4);  cout<<“0”;
   }
  }
  cout<<endl;
}
return true;
}
// 求矩阵的转置矩阵
bool TransposeSMatrix( )
{
TSMatrix M,T;    //定义 预转置的矩阵
InPutTSMatrix(M, 0卡塔尔;    //输入矩阵
int num[MAXROW+1];
int cpot[MAXROW+1];      //   塑造协理数组
int q,p,t;
T.tu=M.tu;   T.mu=M.nu;   T.nu=M.mu;
if(T.tu)
{
  for(int col=1;col<=M.nu;col++)
   num[col]=0;
  for(t=1;t<=M.tu;t++)
   ++num[M.data[t].j];
  cpot[1]=1;
  for(int i=2;i<=M.nu;i++)
   cpot[i]=cpot[i-1]+num[i-1];   
//   求出每一列中国和北美洲零成分在莫斯利安组中冒出的位置
  for(p=1;p<=M.tu;p++)
  {
   col=M.data[p].j;
   q=cpot[col];
   T.data[q].i=col;
   T.data[q].j=M.data[p].i;
   T.data[q].e=M.data[p].e;
   ++cpot[col];
  }
}
cout<<“输入矩阵的转置矩阵为”<<endl;
OutPutSMatrix(T);
return true;
}
bool Count(RLSMatrix &T)
{
int num[MAXROW+1];
for(int col=1;col<=T.mu;col++)
  num[col]=0;         
for(col=1;col<=T.tu;col++)
  ++num[T.data[col].i];
T.rpos[1]=1;
for(int i=2;i<=T.mu;i++)
  T.rpos[i]=T.rpos[i-1]+num[i-1];    //
求取每生龙活虎行中国和北美洲零成分在伊利组中现身的职位
return true;
}
// 四个矩阵相乘
bool MultSMatrix ( )
{
科雷傲LSMatrix M,N,Q;  // 营造八个带“链接消息”的伊利组表示的数组
InPutTSMatrix(M,1卡塔尔(قطر‎;  //  用普通伊利组方式输入数组
InPutTSMatrix(N,1);
Count(M);   Count(N);
if(M.nu!=N.mu)    return false;
Q.mu=M.mu;    Q.nu=N.nu;   Q.tu=0;   //     Q初始化
int ctemp[MAXROW+1];            //    补助数组
int arow,tp,p,brow,t,q,ccol;
if(M.tu*N.tu)
{            //  Q是非零 矩阵
  for( arow=1;arow<=M.mu;arow++)
  {
   for(int x=1;x<=N.nu;x++卡塔尔国      // 当前进各要素累计器清零
    ctemp[x]=0;
   Q.rpos[arow]=Q.tu+1;         //  当前进的第4个非零成分在伊利组中的地点为此行前所有非零元素+1
   if(arow<M.mu)
    tp=M.rpos[arow+1];
   else
    tp=M.tu+1;
   for(p=M.rpos[arow];p<tp;p++)
   {     //   对当前进每种非 零成分进行操作
   
brow=M.data[p].j;            //  在N中找到i值也操作元素的j值相等的行
    if(brow<N.mu)
     t=N.rpos[brow+1];
    else
     t=N.tu+1;
    for(q=N.rpos[brow];q<t;q++)
    {      //  对搜索的行业 每一种非零成分举行操作
     ccol=N.data[q].j;
     ctemp[ccol] += M.data[p].e*N.data[q].e;    //   
将乘拿到对应值放在相应的要素累计器里面
    }
   }
   for(ccol=1;ccol<=Q.nu;ccol++卡塔尔        //   对曾经求出的累积器中的值压缩到Q中
    if(ctemp[ccol])
    {
     if(++Q.tu>MAXSIZE)
      return false;
     Q.data[Q.tu].e=ctemp[ccol];
     Q.data[Q.tu].i=arow;
     Q.data[Q.tu].j=ccol;
    }
  }
}
OutPutSMatrix(Q);
return true;
}
bool CreateSMatrix_OL(CrossList & M)
{          //   创制十字链 表
int x,y,m;
cout<<“请输入矩阵的行,列,及非零成分个数”<<endl;
cin>>M.mu>>M.nu>>M.tu;
if(!(M.rhead=(OLink*)malloc((M.mu+1)*sizeof(OLink))))    exit(0);
if(!(M.chead=(OLink*)malloc((M.nu+1)*sizeof(OLink))))    exit(0);
for(x=0;x<=M.mu;x++)
  M.rhead[x]=NULL;       // 开首化各行,列头指针,分别为NULL
for(x=0;x<=M.nu;x++)
  M.chead[x]=NULL;
cout<<“请按伊利组的格式输入数组:”<<endl;
for(int i=1;i<=M.tu;i++)
{
  cin>>x>>y>>m;      //  按专擅顺序输入非零元,(普通安慕希组方式输入)
  OLink p,q;
  if(!(p=(OLink)malloc(sizeof(OLNode))))
   exit(0State of Qatar;    // 开拓新节点,用来储存输入的新因素
  p->i=x;   p->j=y;    p->e=m;
  if(M.rhead[x]==NULL||M.rhead[x]->j>y)
  {
   p->right=M.rhead[x];     M.rhead[x]=p;            
  }
  else
  {                           
   for(q=M.rhead[x];(q->right卡塔尔&&(q->right->j<yState of Qatar;q=q->right卡塔尔国;        //   查找节点在行表中的插入地方
   p->right=q->right;      q->right=p;     //   达成行插入
  }
  if(M.chead[y]==NULL||M.chead[y]->i>x)
  {
   p->down=M.chead[y];       M.chead[y]=p;
  }
  else
  {
   for(q=M.chead[y];(q->downState of Qatar&&(q->down->i<x卡塔尔(قطر‎;q=q->down卡塔尔国;   
//       查找节点在列表中的插入地方
   p->down=q->down;        q->down=p;                     
//  达成列插入
  }
}
return true;
}
bool OutPutSMatrix_OL(CrossList T)
{                //  输 出十字链表,用平日数组情势出口
for(int i=1;i<=T.mu;i++)
{
  OLink p=T.rhead[i];
  for(int j=1;j<=T.nu;j++)
  {
   if((p)&&(j==p->j))
   {
    cout<<setw(3)<<p->e;
    p=p->right;
   }
   else
    cout<<setw(3)<<“0”;
  }
  cout<<endl;
}
return true;
}
//矩阵的加法
bool AddSMatrix()
{
CrossList M,N;          //  创设多个十字链表对象,并开头化
CreateSMatrix_OL(M);
CreateSMatrix_OL(N);
cout<<“输入的两矩阵的和矩阵为:”<<endl;
OLink pa,pb,pre
,hl[MAXROW+1];            //定义协理指针,pa,pb分别为M,N当前相比较的元素,pre为pa的先驱者成分
for(int x=1;x<=M.nu;x++)
  hl[x]=M.chead[x];
for(int k=1;k<=M.mu;k++)
{              // 对M的每豆蔻梢头行实行操作
  pa=M.rhead[k];   pb=N.rhead[k];    pre=NULL;
  while(pb)
  {                        // 把N中此行的各种成分抽出,
   OLink p;
   if(!(p=(OLink)malloc(sizeof(OLNode))))
    exit(0卡塔尔;       //  开发新节点,存款和储蓄N中收取的成分
   p->e=pb->e;    p->i=pb->i;     p->j=pb->j;
   if(NULL==pa||pa->j>pb->j)
   {            //  当 M此行已经济检察查完恐怕pb因该放在pa前边
    if(NULL==pre)
     M.rhead[p->i]=p;
    else
     pre->right=p;
    p->right=pa;
    pre=p;
    if(NULL==M.chead[p->j])
    {          // 进行列插入
     M.chead[p->j]=p;
     p->down=NULL;
    }
    else
    {
     p->down=hl[p->j]->down;
     hl[p->j]->down=p;
    }
    hl[p->j]=p;
    pb=pb->right;
   }
   else
    if((NULL!=pa)&&pa->j<pb->j)
    {           //  如果那个时候的pb成分因该放在pa前边,则取以往的pa再来比较
     pre=pa;        pa=pa->right;
    }
    else
     if(pa->j==pb->j)
     {           // 若是pa,pb坐落于同一个位置上,则将值相加
      pa->e += pb->e;
      if(!pa->e)
      {                   //
假若相加后的和为0,则删除此节点,同一时候退换此因素坐在行,列的前人元素的相应值
       if(NULL==pre卡塔尔(قطر‎               // 修正行四驱成分值
        M.rhead[pa->i]=pa->right;
       else
        pre->right=pa->right;
       p=pa;    pa=pa->right;
       if(M.chead[p->j]==p)
        M.chead[p->j]=hl[p->j]=p->down;    //
改过列后驱成分值
       else
        hl[p->j]->down=p->down;
       free(p);
       pb=pb->right;
      }
      else
      {
       pa=pa->right;   pb=pb->right;
      }
     }

                                  目录
          引用请表明 hzh512
学业贴1:十进制数转二进制数,并认清出有1的职位
学业贴 2:线索二叉树的中序线索化及其遍历
学业贴3:荒废矩阵的加减乘除转置运算
作业贴4:完全二叉树的论断算法
学业贴5:多项式的相 乘
作业贴6:Huffman 编码
学业贴7:二叉树的操作,创设、各样遍历
学业贴8:[问题陈说]设有n个人围坐生龙活虎圈,现从有些人领头报数,数到m的人出列,接着从下一人先导重新起首报数,
数到m的人又
        出列,如次下去,直到
全体的人都出列甘休。试设计分明他们出列的朝气蓬勃风华正茂的次第
        1)在顺序存储结构上得以达成上述进程。
        2)在循环链表上落到实处以上进程。
学业贴9:链表的插入排序
                                   内容
学业贴1:十进制数转二进制数,并认清出有1的岗位
例程:

澳门新葡亰平台官网 3程序代码:

澳门新葡亰平台官网 4程序代码:

澳门新葡亰平台官网 5程序代码:

/*
十进制数转二进制数,并认清出有1的地点
前后相继的根本观念是:
按位与的特点是,是参与运算的两数各对应的二进位相与。唯有对应的多少个二进位均为1时,结果位才为1,不然为0。
也正是说,按位与运算有3个对象,分别是八个参与运算的五个数和运算有的结果。那么些和小高校上学的平时加法同样。如:a+b=c,,a,b,c分别是3个对
象。雷同的,与运算也是后生可畏一律的意味:a & b = c.
只可是是与的野趣和加法的意趣不切合而已。
基于标题必要,大家早就取得了三个涉足运算的多少,正是要改换的数,今后我们供给得到更改后的数,依照与运算法规,我们组织三个数,分别和待转变的数举行与运算,得到每个人的值,要么是0,要么是1。
*/
#include <stdio.h>
int main(void)
{
const int iTimes=sizeof(int) * 8;
int x;
int iMask=1;
printf(“nDEC:”);
scanf(“%d”,&x);
int x2[iTimes];
int i;
for( i=0 ; i<iTimes ; i++ )
{
  x2[i]=x & iMask;
  iMask = iMask << 1;
}
printf(“n(%d)Binary=”,x);
for( i=iTimes -1 ; i >=0 ; i– )
{
  printf(“%d”,x2[i] ? 1 : 0 );
  if(i%4==0)
   printf(” “);
}
printf(“n 有1的二进制位是:”卡塔尔(قطر‎;
for( i=iTimes -1 ; i >=0 ; i– )
{
  if(x2[i])
            printf(” %d “,i);
}
printf(“n”);
return 0;
}

作业贴3:荒芜矩阵的加减乘除转置运算
例程:

/*对二叉树进行 档次遍历,在遍历过程中对每二个结点实行检查:
  (1State of Qatar假诺当前结点未有右子树,则剩下的全方位结点必得既没有左子树,又从未右子树;
  (2卡塔尔国假使当前结点有右子树,则它必得也可以有左子树.
  如果还要满足(1卡塔尔国(2State of Qatar,则是全然二叉树;不然不是.
您看看您那一条不满意。*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef char TElemType;
typedef struct BiTNode
{
    TElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//////////////////////////////////////////////队列定义
typedef struct QNode
{
    BiTree data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;
////////////////////////////////////队列的基本操作
void InitQueue(LinkQueue *Q)
{
    Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q->front) exit(0);
    Q->front->next=NULL;
}
void DestoryQueue(LinkQueue *Q)
{
    while(Q->front)//*******
    {
        Q->rear=Q->front->next;
        free(Q->front);
        Q->front=Q->rear;
    }
}
void EnQueue(LinkQueue *Q,BiTNode *e)
{
    QueuePtr p;
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p) exit(0);
    p->data=e;//表达 那么些结点的七个域1
    p->next=NULL;//2
    Q->rear->next=p;
    Q->rear=p;
}
void DeQueue(LinkQueue *Q,BiTree *e)
{
    QueuePtr p;
    if(Q->front==Q->rear) exit(0);
    p=Q->front->next;
    *e=p->data;
    Q->front->next=p->next;
//    free(p);
    if(Q->rear==p)
        Q->rear=Q->front;
    free(p);//
}
int QueueEmpty(LinkQueue *Q)
{
QueuePtr tfront = Q->front;
    if(Q->front==Q->rear)
        return(1);
    else
{
  while (tfront != Q->rear)
  {
   if (tfront != NULL)
    return 0;
  }
        return 1;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
BiTree CreatBiTree(卡塔尔国//先序建立二叉链表
{
    TElemType ch;
    BiTree T;
    scanf(“%c”,&ch);
    if(ch==’ ‘)
        T=NULL;
    else
    {
        T=(BiTree)malloc(sizeof(BiTNode));
        if(!T)
            exit(0);
        T->data=ch;
        T->lchild=CreatBiTree();
        T->rchild=CreatBiTree();
    }
    return T;
}
//判别是或不是为完全二叉树
int LayerTraverse(BiTree TState of Qatar//通过层序遍历整编
{
// 对二叉树进行等级次序遍历,在遍历进度中对每多个结点举行自己评论:
//
(1卡塔尔国即使当前结点未有右子树,则剩下的总体结点必需既没有左子树,又从不右子树;
// (2卡塔尔(قطر‎若是当前结点有右子树,则它必得也许有左子树.
bool flag = true;
bool bcomfine = false;
    LinkQueue queue;
    InitQueue(&queue);
    if(T)
        EnQueue(&queue,T);
    else
    {
        printf(“该树为空 树!n”);
  return true;
    }
    while(!QueueEmpty(&queue))
    {
        DeQueue(&queue,&T);
  if (!T->lchild && T->rchild)
   return flag=false;
  if (bcomfine && (T->lchild || T->rchild))
   return flag = false;
  if (T->lchild != NULL)
   EnQueue(&queue, T->lchild);
  if (T->rchild != NULL)
   EnQueue(&queue, T->rchild);
  else
   bcomfine = true;
    }
    return(flag);
}
void main()
{
    BiTree t;
    printf(“<———— 先序建树—————>n”);
    printf(“请按先序遍历种类输
入二叉树中逐生机勃勃结点的值(字符卡塔尔国,若为空树时输入空格键:n”);
    printf(“<参照他事他说加以考查数
据:abc@@de@g@@f@@@,则用空格键表示@,输完后再输入四个回车键.>n”);
    t=CreatBiTree();
    printf(“n”);
    printf(“<—— 推断是还是不是为完全二叉树操作—->n”);
    if(LayerTraverse(t))
        printf(“该二叉树是 完全二叉树!n”);
    else
        printf(“该二叉树不 是完全二叉树!n”);
}

澳门新葡亰平台官网 6程序代码:

作业贴4:完全二叉树的决断算法
例程:

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图