c語言實現鏈表

A. c語言 建立一個鏈表，實現增刪改查

下面是以前寫的一個關於鏈表的綜合操作，你可以看看，應該可以滿足你的要求。
/********************************************************************
created: 2009/09/15
created: 16:9:2009 17:20
filename: E:\dd\lianbiao\lianbiao.cpp
author:
purpose: 一個win32 的控制台程序
實現單項鏈表的數據刪除、插入、排序等功能
*********************************************************************/
#include <stdio.h>
#include "windows.h"
#include "malloc.h"

#define LEN sizeof(struct student)
#define NULL 0
#define N 5 //N為所要創建的鏈表的長度

int n = 0; //定義全局變數n，表示鏈表的節點個數
/*******************************************************************
Author/data: /2009/09/15
Description: 聲明一個結構體作為鏈表的節點.
tip: student 只是一個標簽,是不能聲明變數的
*********************************************************************/
struct student
{
int num;
float cj;
struct student *Pnext;
};

/*******************************************************************
Author/data: /2009/09/15
Description: 創建一個動態鏈表
參數: 返回鏈表的第一個節點的地址
x 為鏈表的長度
*********************************************************************/
struct student *pa(int x)
{
struct student *head;
struct student *p1,*p2;

// n = 0;
p1 = p2 = (struct student *)malloc(LEN); //開辟一個結構體內存
fflush(stdin); // 清除緩沖區數據 避免直接讀入緩沖區數據
scanf("%d,%f",&p1->num,&p1->cj);
head = NULL;
while(p1->Pnext != NULL)
{
n = n+1;
if(n == 1)
{
head = p1; // 鏈表的頭地址
}
else
{
p2->Pnext = p1; //鏈接鏈表數據
}
/* 判斷是否最後一個 */
if(n >= x)
{
p1->Pnext = NULL;
}
else
{
p2 = p1;
p1 = (struct student *)malloc(LEN);
fflush(stdin);
scanf("%d,%f",&p1->num,&p1->cj);
}
}
return(head);
}
/*******************************************************************
Author/data: /2009/09/15
Description: 輸出一個鏈表
參數: head為第一個節點的地址
*********************************************************************/
void print(struct student *head)
{
struct student *p;

int i = 0;
printf("\nNow,These %d records are:\n",n);
p = head;
if(head != NULL) // 如果鏈表不是空的，則進行數據輸出
{
do
{
printf("%d\t",i++);
printf("%5d %5.1f\n",p->num,p->cj); // 輸出鏈表數據
p = p->Pnext;
}while(p != NULL);
}
}
/*******************************************************************
Author/data: /2009/09/16
Description: 釋放動態鏈表的地址空間
參數: 鏈表的頭地址head
無返回值
*********************************************************************/
void freelinkspace(struct student *head)
{
struct student Ltemp;
Ltemp.Pnext = head->Pnext; // Ltemp 用來存放->next,避免空間被
// 釋放後,找不到下一個結點的地址
while(head->Pnext != NULL) // 判斷是否已經空間釋放到最後一個
{
free(head);
head = Ltemp.Pnext;
Ltemp.Pnext = head->Pnext;
}
free(head); // 釋放最後一個結點空間
}

/*******************************************************************
Author/data: /2009/09/15
Description: 刪除鏈表鏈表中的一個結點
參數: head 為第一個節點的地址
num 為要刪除結點的序號（head->num）
*********************************************************************/
struct student *del(struct student *head,int num)
{
struct student *p1,*p2;
p1 = head;
while(p1->num!=num && p1->Pnext!=NULL) // 尋找要刪除的結點
{
p2 = p1; // p2 存放刪除結點的前一個結點地址
p1 = p1->Pnext; // p1 存放要刪除的結點
}
if(num == p1->num) // 是否找到要刪除結點
{
if(p1 == head) // 刪除的是第一個結點
{
head = p1->Pnext;
}
else if(p1->Pnext == NULL) // 刪除的是最後一個結點
{
p2->Pnext = NULL;
}
else // 刪除中間的結點
{
p2->Pnext = p1->Pnext;
p1->Pnext = NULL;
}
printf("delete: %d\n",num);
n = n-1; // 鏈表長度 - 1
}
else
{
printf("%d not been found! \n",num);
}
delete(p1);
return(head);
}
/*******************************************************************
Author/data: /2009/09/16
Description: 添加一個結點到鏈表中
參數: head 為第一個結點的地址指針
stud 為要插入的結點的地址指針
*********************************************************************/
struct student *insert(struct student *head,struct student *stud)
{
struct student *p0,*p1,*p2;
p0 = stud;
p1 = head;
while(p0->num>p1->num && p1->Pnext!=NULL) // 找到添加結點的位置
{
p2 = p1; // p2 存放要添加的前一個結點的地址
p1 = p1->Pnext; // p1 存放要添加的後一個結點的地址
}
if(p0->num<=p1->num && p1->Pnext!=NULL)
{
if(p1 == head) // 添加結點到第一個位置
{
p0->Pnext = p1;
head = p0;
}
else
{
p2->Pnext = p0;
p0->Pnext = p1;
}
}
else // 添加結點到最後一個位置
{

p1->Pnext = p0;
p0->Pnext = NULL;
}
n = n+1; // 結點數目 + 1
return(head);
}
/*******************************************************************
Author/data: /2009/09/16
Description: 鏈表的重新排序===按照.num（不能重復）的大小從小到大排
列鏈表數據
參數: head 接收鏈表第一個節點的地址指針
返回值為新生成鏈表的第一個節點的地址指針
*********************************************************************/
struct student *linkpaix(struct student *head)
{
struct student *stemp,*ltemp,*shead,*head_h; /* */
struct student *p,*q; /* 申請兩個鏈表指針，用來儲存鏈表交換過
程的中間值 */
head_h = head;
ltemp = head;

p = (struct student *) malloc(LEN);
q = (struct student *) malloc(LEN); /* 為p，q開辟動態存儲空間 */

/* -==== 先將鏈表的第一個數據與其他數據比較 ====- */
while(head->Pnext != NULL)
{
shead = head;
head = head->Pnext;
if(ltemp->num > head->num)
{
if(ltemp == shead)
{
ltemp ->Pnext = head ->Pnext;
head ->Pnext = ltemp;
}
else
{
p->Pnext = head ->Pnext;
q->Pnext = ltemp ->Pnext;
head ->Pnext = q->Pnext;
shead ->Pnext = ltemp;
ltemp ->Pnext = p->Pnext;
}
head_h = head;
head = ltemp;
ltemp = head_h;
}

}
/* -==== 先將鏈表的第一個數據與其他數據比較 ====- */

/* -==== 比較鏈表第一個以外的數據 ====- */
while(ltemp ->Pnext != NULL)
{
stemp = ltemp;
ltemp = ltemp ->Pnext;
head = ltemp;
while(head->Pnext != NULL)
{
shead = head;
head = head->Pnext;
if(ltemp->num > head->num)
{
if(ltemp == shead)
{
p->Pnext = head ->Pnext;
stemp ->Pnext = head;
head ->Pnext = ltemp;
ltemp ->Pnext = p->Pnext;
}
else
{
p->Pnext = head ->Pnext;
q->Pnext = ltemp ->Pnext;
stemp ->Pnext = head;
head ->Pnext = q->Pnext;
shead ->Pnext = ltemp;
ltemp ->Pnext = p->Pnext;
}
head = ltemp;
ltemp = stemp ->Pnext;
}
}

}
/* -==== 比較鏈表第一個以外的數據 ====- */

free(p);
free(q); // 釋放p，q的動態存儲空間
return(head_h);
}

/*******************************************************************
Author/data: /2009/09/15
Description: 主函數
參數:
*********************************************************************/
void main()
{
struct student *phead,*pins; // 定義2個鏈表指針
int delnum, selflog,flog_a = 1,Nf = 1; // 要刪除的對象id
char delflog ; // 刪除標志y/n
char insflog, flog_nx = 'n';
char flog_free ; // 釋放標志
/* === 輸入N個數據 === N 為定值
printf("please input %d numbers:\n",N);
phead = pa(N); // 創建一個動態鏈表，並賦值
print(phead); // 輸出鏈表數據
*/

/* === 輸入Nx個數據 === Nx 為輸入值 === */
int Nx; // Nx 想要輸入的鏈表長度
printf("How long do you want establish? \t");
fflush(stdin);
scanf("%d",&Nx);
/* -== 判斷創建的是否是一個空鏈表 ==- */
while(Nx == 0)
{
printf("您要創建的是一個空鏈表，是否確定？y/n \t");
fflush(stdin);
scanf("%c",&flog_nx);
if(flog_nx == 'n')
{
printf("How long do you want input?\t");
fflush(stdin);
scanf("%d",&Nx);
}
else if(flog_nx == 'y') goto endl;
else
{
printf("wrong input!\n");
printf("How long do you want input?\t");
fflush(stdin);
scanf("%d",&Nx);
}
}

printf("please input %d numbers: ",Nx);
printf("如:1,3 兩個數中間以,隔開\n");
phead = pa(Nx); // 創建一個動態鏈表，並賦值
print(phead); // 輸出鏈表數據

/* -== 鏈表操作 ==- */
while(flog_a)
{
if(phead == NULL) {printf("鏈表已空,無法操作\n"); flog_a = 0; break;}
printf("\n操作\n1:\t插入數據\n2:\t刪除數據\n3:\t排序\n4:\t清屏\n5:\t輸出現在的鏈表數據\n0:\texit\n");
printf("\nPlease input:\t");
fflush(stdin);
if(scanf("%d",&selflog)) // select flog 選擇項
switch(selflog)
{
case 1 :
/* ====== 插入數據到鏈表 ====== */
printf("insert someone? y/n\t");
fflush(stdin);
scanf("%c",&insflog);
while(insflog != 'n')
{
while(insflog != 'y'&& insflog != 'n')
{
printf("wrnong input,please input again. \n");
printf("another one? y/n\t");
fflush(stdin);
scanf("%c",&insflog);
}
printf("please input the date:\n");
pins = (struct student *)malloc(LEN);
fflush(stdin);
scanf("%d,%f",&pins->num,&pins->cj);
phead = insert(phead,pins);
print(phead);

printf("another one? y/n\t");
fflush(stdin);
scanf("%c",&insflog);
while(insflog != 'y'&& insflog != 'n')
{
printf("wrnong input,please input again. \n");
printf("another one? y/n\t");
fflush(stdin);
scanf("%c",&insflog);
}
}
/* ====== 插入數據到鏈表 ====== */
break;

case 2 :
/* ====== 刪除鏈表中的數據 ====== */
printf("del someone? y/n\t");
fflush(stdin);
scanf("%c",&delflog);
while(delflog != 'n' && phead != NULL)
{
while(delflog != 'y'&& delflog != 'n')
{
printf("wrnong input,please input again. \n");
printf("del someone? y/n\t");
fflush(stdin);
scanf("%c",&delflog);
}
printf("please input the student what you want del:\n");
fflush(stdin);
scanf("%d",&delnum);
phead = del(phead,delnum);
print(phead);

printf("another one? y/n\t");
fflush(stdin);
scanf("%c",&delflog);
if((n+1)==0)
{
printf("There is no more num could be del!\n");
break;
}
}
/* ====== 刪除鏈表中的數據 ====== */
break;

case 3 :
/* ====== 排列鏈表數據 ====== */
printf("\n排序之後：");
phead = linkpaix(phead);
print(phead); // 排序該數據鏈表
/* ====== 排列鏈表數據 ====== */
break;
case 4 :// clrscr();
system("cls");
break;

case 5 : print(phead); break;
case 0 : flog_a = 0 ; break; /* 退出 */

default : printf("wrong input\nPlease input again");
break;
}
else printf("非法輸入!\n");
}
endl: while(1)
{
if(Nx == 0)
{
printf("Can't establish the link!\n");
break;
}
printf("\n保留數據？y/n\t"); // 是否釋放地址空間
fflush(stdin);
scanf("%c",&flog_free);
if(flog_free == 'y')
{
break;
}
else if(flog_free == 'n')
{
freelinkspace(phead);
break;
}
else
{
printf("wrong input!\n");
}
}

printf("OVER!\nGOOD LUCK!\n");
}

B. 用C語言實現鏈表的演算法

這個是我們數據結構上機實驗的鏈表問題，
#include<stdio.h>
#include<malloc.h>
#define
LEN
sizeof(LinkNode)
typedef
int
Datatype;
typedef
int
Status;
typedef
struct
LinkNode{
Datatype
data;
struct
LinkNode
*next;
}
LinkNode,*LinkList;
typedef
struct
OrderedList
{
LinkNode
*head,*tail;
int
Listsize;
}
OrderedList;//有序循環鏈表的頭節點head,尾接接節點
tail及長度Listsize
Status
InitList(OrderedList
*List)//生成循環鏈表頭節點
{
List->tail=List->head=(LinkList)malloc(LEN);
if(List->head==NULL)
return
0;
else
{
List->head->next=List->tail;
List->tail->next=List->head;
List->Listsize=0;
return
1;
}
}
void
OrderedInsert(OrderedList
*List,Datatype
data)//每調用一次有序插入data形成有序的(從小到大)的鏈表
{
LinkNode
*p
,*q;
if(List->head==List->tail->next)
{
p=(LinkNode*)malloc(LEN);
p->data
=
data;
List->head->next=p;
p->next=List->tail;
List->Listsize++;
}
else
{
p=List->head->next;
q
=
List->head;
while(p->data<data&&p!=List->tail)
{
q
=
p;
p=p->next;
}
if(p->data==data)
{printf("YOu
have
input
the
same
datas
%d\n\t
YOu
should
input
another
data
\n",data);
scanf("%d",&data);
OrderedInsert(List,data);
}
else
{
p=(LinkNode*)malloc(LEN);
p->data
=
data;
p->next
=
q->next;
q->next
=
p;
List->Listsize++;
}
}
}
void
Creatset(OrderedList
*List)//多次調用OrderedInsert()生成有序鏈表即集合List
{
Datatype
data;
int
setsize
,
i=0;
printf("Please
input
the
setsize
you
want
to
creat:\n");
scanf("%d",&setsize);
InitList(List);
if(setsize==0)
printf("You
needen't
input
any
data\n");
else
if(setsize==1)
printf("Please
input
a
single
data\n");
else
printf("Please
input
%d
different
datas;\n",setsize);
while(i<setsize||setsize>List->Listsize)//當循環次數i小於setsize或者集合內實際元素數List.Listsize小於setsize時一直循環下去
{
scanf("%d",&data);
OrderedInsert(List,data);
i++;
}
}
void
Append(OrderedList
*List,Datatype
data)//在循環鏈表的最後面追加
一個data
{
LinkNode
*p;
p=(LinkNode*)malloc(LEN);
p->data=data;
List->tail=List->tail->next=p;
List->tail->next=List->head;
List->Listsize+=1;
}
void
MergeList(OrderedList
La,OrderedList
Lb,OrderedList
*Lc)//有序循環鏈表ListLa,ListLb求並集生成ListLc
{
LinkList
Pa,Pb;
Pa=La.head->next;Pb=Lb.head->next;
while(Pa!=La.tail&&Pb!=Lb.tail)
{
if(Pa->data<=Pb->data)
{
Append(Lc,Pa->data);
Pa=Pa->next;
}
else
{
Append(Lc,Pb->data);Pb=Pb->next;
}
}
while(Pa!=La.tail)
{
Append(
Lc,Pa->data);Pa=Pa->next;}
while(Pb!=Lb.tail)
{
Append(Lc,Pb->data);Pb=Pb->next;}
}
void
Print(OrderedList
List)
{
LinkNode
*p;
p=List.head->next;
if(p->next==List.head)
printf("No
Elem\n");
while(p!=List.head)
{
printf("%5d",p->data);p=p->next;
}
printf("\n");
}
void
main()
{
OrderedList
ListLa,ListLb,ListLc;
Creatset(&ListLa);
Creatset(&ListLb);
InitList(&ListLc);
MergeList(ListLa,ListLb,&ListLc);
printf("The
orgnial
list
ListLa,ListLb:\n");
Print(ListLa);
Print(ListLb);
printf("The
Merge
list
ListLc;\n");
Print(ListLc);
}

C. c語言中鏈表的概念和簡單的實現

鏈表

鏈表概述
鏈表是一種常見的重要的數據結構。它是動態地進行存儲分配的一種結構。它可以根據需要開辟內存單元。鏈表有一個「頭指針」變數，以head表示，它存放一個地址。該地址指向一個元素。鏈表中每一個元素稱為「結點」，每個結點都應包括兩個部分：一為用戶需要用的實際數據，二為下一個結點的地址。因此，head指向第一個元素：第一個元素又指向第二個元素；……，直到最後一個元素，該元素不再指向其它元素，它稱為「表尾」，它的地址部分放一個「NULL」（表示「空地址」），鏈表到此結束。

單向鏈表
單向鏈表的每個結點中除信息域以外還有一個指針域，用來指出其後續結點，單向鏈表的最後一個結點的指針域為空(NULL)。單向鏈表由頭指針唯一確定，因此單向鏈表可以用頭指針的名字來命名，例如頭指針名為head的單向鏈表稱為表head，頭指針指向單向鏈表的第一個結點。

簡單實現為：

#define NULL 0

typedef int DATATYPE

typedef struct node

{DATATYPE info；

node *next;

}LINKLIST;

雙向鏈表
每個結點中只包括一個指向下個結點的指針域，這種鏈表稱為單向鏈表。如果要在單向鏈表一個指針所指的當前位置插入一個新結點，就必須從鏈表頭指針開始逐個遍歷直到當前指針所指結點的前一結點，修改這個結點的指針。雙向鏈表的每個結點中包括兩個指針域，分別指向該結點的前一個結點和後一個結點。在雙向鏈表中由任何一個結點都很容易找到其前面的結點和後面的結點，而不需要在上述的插入(及刪除)操作中由頭結點開始尋找。

簡單實現為：

typedef struct node

{ DATATYPE info；

node *priv, *next;

}DINKLIST；

循環鏈表
單向鏈表的最後一個結點的指針域為空（NULL）。如果將這個指針里利用起來，以指向單向鏈表的第一個結點，就組成一個單向循環鏈表。

這里有一篇好文章：http://myweb.yzu.e.cn/toby88/c/cstudy/shenru/jiegou/lianbiao.htm

D. 如何用C語言編寫一個鏈表

#include "stdio.h"
#include "stdlib.h"
#include "malloc.h"

struct Node
{
int data;//數據域
struct Node * next;//指針域
};

/*************************************************************************************
*函數名稱:Create
*函數功能:創建鏈表.
*輸入:各節點的data
*返回值:指針head
*************************************************************************************/
struct Node * Create()
{
struct Node *head,*p1,*p2;
head = NULL;
p1 = p2 = (struct Node *)malloc(sizeof(struct Node));
printf("Input the linklist (Input 0 to stop):\n");
scanf("%d",&p1->data);
while(p1->data!=0)
{
if(head == NULL){
head = p1;
}else{
p2->next = p1;
p2 =p1;
}
p1 = (struct Node *)malloc(sizeof(struct Node));
scanf("%d",&p1->data);
}
p2->next = NULL;
return head;
}
/*************************************************************************************
*函數名稱:insert
*函數功能:在鏈表中插入元素.
*輸入:head 鏈表頭指針,p新元素插入位置,x 新元素中的數據域內容
*返回值:無
*************************************************************************************/
void insert(struct Node * head,int p,int x)
{
struct Node * tmp = head;
struct Node * tmp2 ;
int i ;
for(i = 0;i<p;i++)
{
if(tmp == NULL)
return ;
if(i<p-1)
tmp = tmp->next;
}
tmp2 = (struct Node *)malloc(sizeof(struct Node));
tmp2->data = x;
tmp2->next = tmp->next;
tmp->next = tmp2;
}
/**************************************************************************************
*函數名稱：del
*函數功能:刪除鏈表中的元素
*輸入:head 鏈表頭指針,p 被刪除元素位置
*返回值:被刪除元素中的數據域.如果刪除失敗返回-1
**************************************************************************************/
int del(struct Node * head,int p)
{
struct Node * tmp = head;
int ret , i;
for(i = 0;i<p;i++)
{
if(tmp == NULL)
return -1;
if(i<p-1)
tmp = tmp->next;
}
ret = tmp->next->data;
tmp->next = tmp->next->next;
return ret;
}
/**************************************************************************************
*函數名稱：print
*函數功能:列印鏈表中的元素
*輸入:head 鏈表頭指針
*返回值:無
**************************************************************************************/
void print(struct Node *head)
{
struct Node *tmp;
for(tmp = head; tmp!=NULL; tmp = tmp->next)
printf("%d ",tmp->data);
printf("\n");
}
/**************************************************************************************
*函數名稱：main
*函數功能:主函數創建鏈表並列印鏈表。
**************************************************************************************/
int main(){
struct Node * head = Create();
print(head);
return 0;
}

E. 如何使用C語言實現兩個鏈表的連接

以前學數據結構做過一個「非遞減的鏈表合並一一個非遞增的鏈表」
程序如下：
#include <stdio.h>
#include <stdlib.h>
typedef struct node{
int data;
struct node *next;
}LinkList;

/* 建立鏈表 */

LinkList *create_link(int m)
{
LinkList *head,*s,*p;
int i;
head=(LinkList *)malloc(sizeof(LinkList));
head->next=NULL;
p=head;
for(i=0;i<m;i++){
s=(LinkList *)malloc(sizeof(LinkList));
if(s==NULL){
printf("failed.\n");
exit(0);
}
scanf("%d",&s->data);
s->next=NULL;
p->next=s;
p=s;

}

return head;
}

/* 2個非遞減的鏈表合並一一個非遞增的鏈表 */

LinkList *add_link(LinkList *head1,LinkList *head2,LinkList *head)
{
LinkList *p1,*p2,*q;
p1=head1->next;
p2=head2->next;
head=q=head1;
q->next=NULL;
while(p1&&p2){
if(p1->data<=p2->data){
q=p1;
p1=p1->next;
}
else{
q=p2;
p2=p2->next;
}
q->next=head1->next;
head1->next=q;
}
while(p1)
{q=p1;
p1=p1->next;
q->next=head1->next;
head1->next=q;}
while(p2)
{q=p2;
p2=p2->next;
q->next=head1->next;
head1->next=q;}

return head;

}

/* 列印鏈表 */

void print_link(LinkList *head)
{
LinkList *p;

p=head->next;
if(!p){
printf("Link is NULL.\n");
exit(0);
}

while(p){
printf("%d ",p->data);
p=p->next;
}

}

int main(void)
{
LinkList *head,*head1,*head2;

int m,n;
printf("input length of Link1:");
scanf("%d",&m);
head=create_link(m);
print_link(head);
printf("\n");
printf("input length of Link2:");
scanf("%d",&n);
head1=create_link(n);

print_link(head1);
printf("\n");

head2=add_link(head,head1,head2);
print_link(head2);
getchar();
getchar();
return 0;
}

F. 用C語言編寫一個鏈表

看完你下面的追問 其實 意思是
讓你把一個已有的 單鏈表
變成反向的單鏈表 對吧

G. C語言如何創建單鏈表

C語言創建單鏈表如下：

#include"stdio.h"

#include"stdlib.h"

#include"malloc.h"

#include "iostream.h"

typedef struct node

{

intdata;

node * next;

}node , * List;

void create(int n)

{

int c;

List s,L;

L=(List)malloc(sizeof(node));

L->next=NULL;

printf("請輸入第1個數據：");

scanf("%d",&c);

L->data=c;

for(int i=2;i<=n;i++)

{

s=(List)malloc(sizeof(node));

printf("請輸入第%d個數據：",i);

scanf("%d",&c);

s->data=c;

s->next=L;

L->next =s;

}

printf("鏈表創建成功！");

}

void main()

{

int n;

printf("請你輸入鏈表的個數：");

scanf("%d",&n);

create(n);

}

H. 單鏈表的C語言實現

在 void creatlist(linklist &lnode,int y) 子函數中加入
linklist l;
int n=10;/*n大小隨意*/
l=(linklist)malloc(sizeof(lnode));
三行
還有main函數里的
break;
改為
exit(0);
null必須是大寫的NULL

I. 實現鏈表（C語言）

鏈表應該沒有很高效的查找演算法吧，只有一個一個按順序查找啊

不過可以設置兩個指針變數，
link* p1,p2;
p1用來遍歷
p2用來記錄與p2相差K-1個節點
當p1遍歷到完鏈表時，p2就是了

J. c語言鏈表代碼

#include<stdio.h>
intmutuallyprime(inta[100],intb[100])
{
inti,j,n;
for(i=0,n=0;a[i];i++)
{
for(j=0;b[j];j++)
{
if(a[i]==b[j])
n++;
}
}
if(n>1)
return0;
else
return1;
}
intmain()
{
intm,n,a[100],b[100],i,j;
scanf("%d%d",&m,&n);
for(i=1,j=0;i<=m;i++)
{
if(!(m%i))
{
a[j]=i;
j++;
}
}
a[j]=0;
for(i=1,j=0;i<=n;i++)
{
if(!(n%i))
{
b[j]=i;
j++;
}
}
b[j]=0;
if(mutuallyprime(a,b))
printf("%d與%d為互質數
",m,n);
else
printf("%d與%d不為互質數
",m,n);
return0;
}