c语言里2&3等于什么

一、c语言里2&3等于什么

1、按位与运算符，两个都为1的时候为为1,2的二进制为10，3的二进制为11。2& 3= 10& 11= 10即二进制 2。以下为示例代码：

2、在这个示例中，我们声明了两个整数变量a和b，并将它们初始化为2和3。然后，我们使用&运算符对它们进行按位与运算，并将结果存储在result变量中。最后，我们使用printf()函数输出a、b和result的值。

3、♡♡有帮助到的话，麻烦采纳哦！♡♡

二、c语言中gcd()函数的用法

1、int GCD(int a,int b)//定义函数，用来计算最大公约数

2、//此处使用了递归，如果b=0,返回a为最大公约数，否则，一直以b与a%b赋给函数，实现辗转相除

3、scanf("%d%d",&a,&b);//取a，b的值

4、answer= GCD(a, b);//把结果赋给answer

5、printf("%d与%d的最大公约数为%d\n", a, b, answer);//输出结果

6、辗转相除法求最大公约数的原理：

7、因为对任意同时整除a和b的数u，有a=su，b=tu，它也能整除r，因为r=a-bq=su-qtu=(s-qt)u。

8、反过来每一个整除b和r的整数v，有 b=sv, r=tv，它也能整除a，因为a=bq+r=svq+tv=(sq+t)v。

9、因此a和b的每一个公因子同时也是b和r的一个公因子，反之亦然。

10、这样由于a和b的全体公因子集合与b和r的全体公因子集合相同，所以a和b的最大公因子必须等于b和r的最大公因子，这就证明了上边的等式。即(a,b)=(b,r)。

11、因而，可以由此，得到两个数的最大公约数。

三、C语言排序

//总共给你整理了7种排序算法：希尔排序，链式基数排序，归并排序

//起泡排序，简单选择排序，树形选择排序，堆排序,先自己看看吧，

//看不懂可以再问身边的人或者查资料,既然可以上网，我相信你所在的地方信息流通方式应该还行,所有的程序全部在VC++6.0下编译通过

typedef int InfoType;//定义其它数据项的类型

#define MAXSIZE 20//一个用作示例的小顺序表的最大长度

typedef int KeyType;//定义关键字类型为整型

InfoType otherinfo;//其它数据项，具体类型在主程中定义

RedType r[MAXSIZE+1];// r[0]闲置或用作哨兵单元

void ShellInsert(SqList&L,int dk)

{//对顺序表L作一趟希尔插入排序。本算法是和一趟直接插入排序相比，

// 1.前后记录位置的增量是dk,而不是1;

// 2.r[0]只是暂存单元,不是哨兵。当j<=0时,插入位置已找到。算法10.4

for(i=dk+1;i<=L.length;++i)

if LT(L.r[i].key,L.r[i-dk].key)

for(j=i-dk;j>0&<(L.r[0].key,L.r[j].key);j-=dk)

L.r[j+dk]=L.r[j];//记录后移，查找插入位置

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);

void ShellSort(SqList&L,int dlta[],int t)

{//按增量序列dlta[0..t-1]对顺序表L作希尔排序。算法10.5

ShellInsert(L,dlta[k]);//一趟增量为dlta[k]的插入排序

printf("第%d趟排序结果:",k+1);

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8},{55,9},{4,10}};

int dt[T]={5,3,1};//增量序列数组

/*****************************************************************/

typedef int InfoType;//定义其它数据项的类型

typedef int KeyType;//定义RedType类型的关键字为整型

struct RedType//记录类型(同c10-1.h)

InfoType otherinfo;//其它数据项

typedef char KeysType;//定义关键字类型为字符型

#include<malloc.h>// malloc()等

#include<limits.h>// INT_MAX等

#include<stdio.h>// EOF(=^Z或F6),NULL

#include<stdlib.h>// atoi()

#include<math.h>// floor(),ceil(),abs()

#include<process.h>// exit()

#include<iostream.h>// cout,cin

typedef int Status;// Status是函数的类型,其值是函数结果状态代码，如OK等

typedef int Boolean;// Boolean是布尔类型,其值是TRUE或FALSE

#define MAX_NUM_OF_KEY 8//关键字项数的最大值

#define RADIX 10//关键字基数，此时是十进制整数的基数

struct SLCell//静态链表的结点类型

KeysType keys[MAX_NUM_OF_KEY];//关键字

InfoType otheritems;//其它数据项

SLCell r[MAX_SPACE];//静态链表的可利用空间，r[0]为头结点

int keynum;//记录的当前关键字个数

int recnum;//静态链表的当前长度

void InitList(SLList&L,RedType D[],int n)

{//初始化静态链表L（把数组D中的数据存于L中）

char c[MAX_NUM_OF_KEY],c1[MAX_NUM_OF_KEY];

int i,j,max=D[0].key;// max为关键字的最大值

L.keynum=int(ceil(log10(max)));

L.r[i].otheritems=D[i-1].otherinfo;

itoa(D[i-1].key,c,10);//将10进制整型转化为字符型,存入c

for(j=strlen(c);j<L.keynum;j++)//若c的长度<max的位数,在c前补'0'

L.r[i].keys[j]=c[L.keynum-1-j];

void Distribute(SLCell r[],int i,ArrType f,ArrType e)//算法10.15

{//静态键表L的r域中记录已按(keys[0],…,keys[i-1])有序。本算法按

//第i个关键字keys[i]建立RADIX个子表,使同一子表中记录的keys[i]相同。

// f[0..RADIX-1]和e[0..RADIX-1]分别指向各子表中第一个和最后一个记录

for(p=r[0].next;p;p=r[p].next)

j=ord(r[p].keys[i]);// ord将记录中第i个关键字映射到[0..RADIX-1]

e[j]=p;//将p所指的结点插入第j个子表中

void Collect(SLCell r[],ArrType f,ArrType e)

{//本算法按keys[i]自小至大地将f[0..RADIX-1]所指各子表依次链接成

//一个链表，e[0..RADIX-1]为各子表的尾指针。算法10.16

for(j=0;!f[j];j=succ(j));//找第一个非空子表，succ为求后继函数

t=e[j];// r[0].next指向第一个非空子表中第一个结点

for(j=succ(j);j<RADIX-1&&!f[j];j=succ(j));//找下一个非空子表

r[t].next=0;// t指向最后一个非空子表中的最后一个结点

for(j=L.keynum-1;j>=0;j--)

{// L是采用静态链表表示的顺序表。对L作基数排序，使得L成为按关键字

//自小到大的有序静态链表，L.r[0]为头结点。算法10.17

L.r[L.recnum].next=0;//将L改造为静态链表

{//按最低位优先依次对各关键字进行分配和收集

Distribute(L.r,i,f,e);//第i趟分配

printf("第%d趟收集后:\n",i+1);

printf("keynum=%d recnum=%d\n",L.keynum,L.recnum);

for(j=L.keynum-1;j>=0;j--)

printf(" otheritems=%d next=%d\n",L.r[i].otheritems,L.r[i].next);

void Sort(SLList L,int adr[])//改此句(类型)

{//求得adr[1..L.length]，adr[i]为静态链表L的第i个最小记录的序号

void Rearrange(SLList&L,int adr[])//改此句(类型)

{// adr给出静态链表L的有序次序，即L.r[adr[i]]是第i小的记录。

//本算法按adr重排L.r，使其有序。算法10.18(L的类型有变)

for(i=1;i<L.recnum;++i)//改此句(类型)

L.r[0]=L.r[i];//暂存记录L.r[i]

{//调整L.r[adr[j]]的记录到位直到adr[j]=i为止

RedType d[N]={{278,1},{109,2},{63,3},{930,4},{589,5},{184,6},{505,7},{269,8},{8,9},{83,10}};

printf("排序前(next域还没赋值):\n");

printf("排序后(静态链表):\n");

adr=(int*)malloc((l.recnum)*sizeof(int));

printf("排序后(重排记录):\n");

/*******************************************/

typedef int InfoType;//定义其它数据项的类型

#define MAXSIZE 20//一个用作示例的小顺序表的最大长度

typedef int KeyType;//定义关键字类型为整型

InfoType otherinfo;//其它数据项，具体类型在主程中定义

RedType r[MAXSIZE+1];// r[0]闲置或用作哨兵单元

void Merge(RedType SR[],RedType TR[],int i,int m,int n)

{//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]算法10.12

for(j=m+1,k=i;i<=m&&j<=n;++k)//将SR中记录由小到大地并入TR

TR[k+l]=SR[i+l];//将剩余的SR[i..m]复制到TR

TR[k+l]=SR[j+l];//将剩余的SR[j..n]复制到TR

void MSort(RedType SR[],RedType TR1[],int s, int t)

{//将SR[s..t]归并排序为TR1[s..t]。算法10.13

m=(s+t)/2;//将SR[s..t]平分为SR[s..m]和SR[m+1..t]

MSort(SR,TR2,s,m);//递归地将SR[s..m]归并为有序的TR2[s..m]

MSort(SR,TR2,m+1,t);//递归地将SR[m+1..t]归并为有序的TR2[m+1..t]

Merge(TR2,TR1,s,m,t);//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]

{//对顺序表L作归并排序。算法10.14

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7}};

/**********************************************/

#include<malloc.h>// malloc()等

#include<limits.h>// INT_MAX等

#include<stdio.h>// EOF(=^Z或F6),NULL

#include<stdlib.h>// atoi()

#include<math.h>// floor(),ceil(),abs()

#include<process.h>// exit()

#include<iostream.h>// cout,cin

void bubble_sort(int a[],int n)

{//将a中整数序列重新排列成自小至大有序的整数序列(起泡排序)

for(i=n-1,change=TRUE;i>1&&change;--i)

int d[N]={49,38,65,97,76,13,27,49};

/****************************************************/

typedef int InfoType;//定义其它数据项的类型

#define MAXSIZE 20//一个用作示例的小顺序表的最大长度

typedef int KeyType;//定义关键字类型为整型

InfoType otherinfo;//其它数据项，具体类型在主程中定义

RedType r[MAXSIZE+1];// r[0]闲置或用作哨兵单元

int SelectMinKey(SqList L,int i)

{//返回在L.r[i..L.length]中key最小的记录的序号

for(j=i+1;j<=L.length;j++)

if(L.r[j].key<min)//找到更小的

{//对顺序表L作简单选择排序。算法10.9

{//选择第i小的记录，并交换到位

j=SelectMinKey(L,i);//在L.r[i..L.length]中选择key最小的记录

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};

/************************************************/

#include<malloc.h>// malloc()等

#include<limits.h>// INT_MAX等

#include<stdio.h>// EOF(=^Z或F6),NULL

#include<stdlib.h>// atoi()

#include<math.h>// floor(),ceil(),abs()

#include<process.h>// exit()

#include<iostream.h>// cout,cin

typedef int Status;// Status是函数的类型,其值是函数结果状态代码，如OK等

typedef int Boolean;// Boolean是布尔类型,其值是TRUE或FALSE

typedef int InfoType;//定义其它数据项的类型

#define MAXSIZE 20//一个用作示例的小顺序表的最大长度

typedef int KeyType;//定义关键字类型为整型

InfoType otherinfo;//其它数据项，具体类型在主程中定义

RedType r[MAXSIZE+1];// r[0]闲置或用作哨兵单元

int i,j,j1,k,k1,l,n=L.length;

l=(int)ceil(log(n)/log(2))+1;//完全二叉树的层数

k=(int)pow(2,l)-1;// l层完全二叉树的结点总数

k1=(int)pow(2,l-1)-1;// l-1层完全二叉树的结点总数

t=(RedType*)malloc(k*sizeof(RedType));//二叉树采用顺序存储结构

for(i=1;i<=n;i++)//将L.r赋给叶子结点

for(i=k1+n;i<k;i++)//给多余的叶子的关键字赋无穷大

t[i].key<t[i+1].key?(t[(i+1)/2-1]=t[i]):(t[(i+1)/2-1]=t[i+1]);

L.r[i+1]=t[0];//将当前最小值赋给L.r[i]

for(j=1;j<l;j++)//沿树根找结点t[0]在叶子中的序号j1

t[2*j1+1].key==t[j1].key?(j1=2*j1+1):(j1=2*j1+2);

j1=(j1+1)/2-1;//序号为j1的结点的双亲结点序号

t[2*j1+1].key<=t[2*j1+2].key?(t[j1]=t[2*j1+1]):(t[j1]=t[2*j1+2]);

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};

/****************************/

typedef int InfoType;//定义其它数据项的类型

#define MAXSIZE 20//一个用作示例的小顺序表的最大长度

typedef int KeyType;//定义关键字类型为整型

InfoType otherinfo;//其它数据项，具体类型在主程中定义

RedType r[MAXSIZE+1];// r[0]闲置或用作哨兵单元

typedef SqList HeapType;//堆采用顺序表存储表示

void HeapAdjust(HeapType&H,int s,int m)//算法10.10

{//已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，本函数

//调整H.r[s]的关键字,使H.r[s..m]成为一个大顶堆(对其中记录的关键字而言)

{//沿key较大的孩子结点向下筛选

if(j<m&<(H.r[j].key,H.r[j+1].key))

{//对顺序表H进行堆排序。算法10.11

for(i=H.length/2;i>0;--i)//把H.r[1..H.length]建成大顶堆

{//将堆顶记录和当前未经排序子序列H.r[1..i]中最后一个记录相互交换

HeapAdjust(H,1,i-1);//将H.r[1..i-1]重新调整为大顶堆

printf("(%d,%d)",H.r[i].key,H.r[i].otherinfo);

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};