❶ C語言編程-單循環
#include<stdio.h>
#include<string.h>
main()
{
chara[10000];
intl,i,sum0,sum1,sum2,sum3,sum4;
while(1){
gets(a);
l=strlen(a);
sum0=0;sum1=0;sum2=0;sum3=0;sum4=0;
for(i=0;i<l;i++)
if(a[i]>='A'&&a[i]<='Z')sum0++;
elseif(a[i]>='a'&&a[i]<='z')sum1++;
elseif(a[i]>='0'&&a[i]<='9')sum2++;
elseif(a[i]=='')sum3++;
elsesum4++;
printf("%d%d%d%d%d
",sum0,sum1,sum2,sum3,sum4);
}
}
如圖所示，望採納。。。。。。
❷ C語言中循環語句有哪些
C提供三種基本的循環語句: for語句、while語句和do-while語句。
一. for循環
for循環是開界的。它的一般形式為:
for(<初始化>; <條件表過式>; <增量>)
語句;
初始化總是一個賦值語句, 它用來給循環控制變數賦初值; 條件表達式是一個關系表達式, 它決定什麼時候退出循環; 增量定義循環控制變數每循環一次後按什麼方式變化。這三個部分之間用";"分開。
例如:
for(i=1; i<=10; i++)
語句;
上例中先給i賦初值1, 判斷i是否小於等於10, 若是則執行語句, 之後值增加1。再重新判斷, 直到條件為假, 即i>10時, 結束循環。
注意:
1. for循環中語句可以為語句體, 但要用"{"和"}"將參加循環的語句括起來。
2. for循環中的"初始化"、"條件表達式"和"增量"都是選擇項, 即可以預設, 但";"不能預設。省略了初始化, 表示不對循環控制變數賦初值。 省略了條件表達式, 則不做其它處理時便成為死循環。省略了增量, 則不對循環控制變數進行操作, 這時可在語句體中加入修改循環控制變數的語句。
3. for循環可以有多層嵌套。
例16:
main()
{
int i, j, k;
printf("i j k\n");
for (i=0; i<2; i++)
for(j=0; j<2; j++)
for(k=0; k<2; k++)
printf(%d %d %d\n", i, j, k);
}
輸出結果為:
i j k
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
二、 while循環
while循環的一般形式為:
while(條件)
語句;
while循環表示當條件為真時, 便執行語句。直到條件為假才結束循環。 並繼續執行循環程序外的後續語句。
例17:
#include<stdio.h>
main()
{
char c;
c=』\0』; /*初始化c*/
while(c!=』\X0D』) /*回車結束循環*/
c=getche(); /*帶回顯的從鍵盤接收字元*/
}
上例中, while循環是以檢查c是否為回車符開始, 因其事先被初始化為空, 所以條件為真, 進入循環等待鍵盤輸入字元; 一旦輸入回車, 則c=』\X0D』, 條件為假, 循環便告結束。
與for循環一樣, while循環總是在循環的頭部檢驗條件, 這就意味著循環可能什麼也不執行就退出。
注意:
1. 在while循環體內也允許空語句。
例如:
while((c=getche())!=』\X0D』);
這個循環直到鍵入回車為止。
2. 可以有多層循環嵌套。
3. 語句可以是語句體, 此時必須用"{"和"}"括起來。
例18:
#include<stdio.h>
main()
{
char c, fname[13];
FILE *fp; /*定義文件指針*/
printf("File name:"); /*提示輸入文件名*/
scanf("%s", fname); /*等待輸入文件名*/
fp=fopen(fname, "r"); /*打開文件只讀*/
while((c=fgetc(fp)!=EOF) /*讀取一個字元並判斷是否到文件結束*/
putchar(c); /*文件未結束時顯示該字元*/
}
三.do-while 循環
do-while 循環的一般格式為:
do
語句;
while(條件);
這個循環與while循環的不同在於: 它先執行循環中的語句, 然後再判斷條
件是否為真, 如果為真則繼續循環; 如果為假, 則終止循環。因此, do-while循
環至少要執行一次循環語句。
同樣當有許多語句參加循環時, 要用"{"和"}"把它們括起來。
❸ C語言單向循環鏈表尾插法問題
建立單向循環鏈表的代碼：
#include<stdio.h>
#include<stdlib.h>
typedefstruct_A{
intdata;
struct_A*next;
}A;
typedefA*IA;
voidcreateDoubleLink(IA*header){
intdata;
IAp;
printf("inputdataendwith-1:");
scanf("%d",&data);
while(data!=-1){
p=(IA)malloc(sizeof(A));
p->data=data;
if(*header==NULL){
*header=p;
(*header)->next=*header;
}
else{
IAq=*header;
while(q->next!=*header){
q=q->next;
}
q->next=p;
q->next->next=*header;
}
scanf("%d",&data);
}
}
voidprint(IAheader){
IAp=header;
if(header==NULL)return;
while(1){
printf("%d ",p->data);
if(p->next==header)break;
p=p->next;
}
printf(" ");
}
intmain()
{
IAheader=NULL;
createDoubleLink(&header);
print(header);
return0;
}
頭結點的意思是鏈表的第一個節點，但這個節點不保存數據。
❹ C語言如何將單鏈表改為單循環鏈表
#include<iostream>
using std::cin;
using std::cout;
using std::endl;
template<class ElemType>
struct Node
{
ElemType data;
Node<ElemType>* next;
Node()
: next(0)
{}
};
//單鏈表的模板類
template<class ElemType>
class Linklist
{
private:
Node<ElemType>* head;
int _length;
public:
Linklist(){};
void Print(void);
void Sort(void);
void Delete(int);
void Creat(void);
void GameDelete(int);
void LinklistToCirclelist();
int Length() { return _length;}
void CombineKeepSame(Linklist<ElemType> &);
void CombineKillSame(Linklist<ElemType> &);
void CopyTo(Linklist<ElemType> &);
~Linklist()
{ while(head->next!=0)
{
Node<ElemType>* tmpNode=head->next;
for(int i=0;i<_length-1;i++)
tmpNode=tmpNode->next;
delete tmpNode;
}
delete head;
};
};
//單鏈表建立後，進行逐一賦值
template<class ElemType>
void Linklist<ElemType>::Creat()
{
int len;
cout<<"該的單鏈表長度：";
cin>>len;
head=new Node<ElemType>;
_length=0;
Node<ElemType>* p;
p=head;
for(int i=0;i<len;i++)
{
p->next=new Node<ElemType>;
cout<<"第"<<i+1<<"個鏈表元素：";
cin>>p->next->data;
p=p->next;
_length++;
}
if(_length != len )
cout<<"輸入的個數不對：len = "<<len<<" _length = "<<_length<<endl;
}
//拷貝函數，將一個對象的數據域拷貝到另一個對象
template<class ElemType>
void Linklist<ElemType>::CopyTo(Linklist<ElemType> &tmpLink)
{
tmpLink._length=_length;
tmpLink.head=new Node<ElemType>;
Node<ElemType> *tmpNode=tmpLink.head;
Node<ElemType> *curListNode=head;
for(int i=0;i<_length;i++)
{
tmpNode->next=new Node<ElemType>;
tmpNode->next->data = curListNode->next->data;
tmpNode = tmpNode->next;
curListNode = curListNode->next;
}
}
//列印函數，對象列印
template<class ElemType>
void Linklist<ElemType>::Print()
{
cout<<"print list : ";
Node<ElemType>* tmpNode=head->next;
for(int i=0;i<_length;i++)
{
cout<<tmpNode->data<<" ";
tmpNode=tmpNode->next;
}
cout<<endl;
}
//排序函數，對象排序
template<class ElemType>
void Linklist<ElemType>::Sort()
{
ElemType temp;
Node<ElemType>* tmpNode=(*head).next;
for(int i=0;i<_length;i++)
{
for(int j=0;j<_length;j++)
{
if((*tmpNode).next==0)tmpNode=(*head).next;
if((*tmpNode).data>(*tmpNode).next->data)
{
temp=(*tmpNode).data;
(*tmpNode).data=((*tmpNode).next)->data;
((*tmpNode).next)->data=temp;
}
else
tmpNode=(*tmpNode).next;
}
}
}
template<class ElemType>
void Linklist<ElemType>::LinklistToCirclelist()//把單鏈表轉化為單循環鏈表
{
Node<ElemType> *tmpNode=head->next;
while(0!=tmpNode->next)
tmpNode=tmpNode->next;
head=head->next;
tmpNode->next=head;
}
template<class ElemType>
void Linklist<ElemType>::Delete(int position)
{
Node<ElemType> *tmpNode=head;
Node<ElemType> *delNode;
for(int i=1;i<position-1&&_length>1;i++)
{
tmpNode=tmpNode->next;
}
if(_length>1)
{
delNode=tmpNode->next;
tmpNode->next=delNode->next;
head=delNode->next;
delete delNode;
_length--;
}
}
template<class ElemType>
void Linklist<ElemType>::GameDelete(int position)
{
while(_length!=1)
{
Delete(position);
Print();
}
}
int main()
{
Linklist<char> LA;
cout<<"請輸入一個單鏈表(字母)："<<endl;
LA.Creat();
LA.Print();
LA.LinklistToCirclelist();//你可以在這設置個斷點看看
int x;
cin>>x;
return 0;
}//這個是我上次試驗寫的，字數限制刪除了兩個函數…………
❺ C語言單循環鏈表的建立.有個地方稍微有點理論上的不明白請幫一下
LZ你首現要搞清楚，q指針到底是用來指向什麼的！
你要弄明白，q指針指的是當前鏈表的最後一個節點。
q->next=p;
//關於這句話，意思就是q永遠是指向當前鏈表的最後一個節點，也就是說q->next在你插入新節點之前是等於頭節點，也就是head，你現在要將新建的節點插入此循環鏈表，即首先要將q->next指向新的節點，也就是p。
q=p;
//還是那句話，q永遠指向的是此循環鏈表的最後一個節點，你插入新的節點以後，此鏈表的最後一個節點，還是原來的q嗎？很明顯。不是，而是插入的新節點p，那麼就要將q指向插入新節點以後的鏈表的最後一個節點，所以才有這句話q=p；
//你可以試想一下，如果沒有這句話，那麼你下次插入新節點的時候，q還是指向最後一個節點嗎？很明顯。不是。q都不是指向最後一個節點了。請問你用q->next=p還能插入新節點嗎?
❻ C語言怎麼動態生成單循環鏈表
在雙向鏈表中，結點除含有數據域外，還有兩個鏈域，一個存儲直接後繼結點地址，一般稱之為右鏈域；一個存儲直接前驅結點地址，一般稱之為左鏈域。
鏈表的C語言實現之循環鏈表及雙向鏈表
一、循環鏈表
循環鏈表是與單鏈表一樣，是一種鏈式的存儲結構，所不同的是，循環鏈表的最後一個結點的指針是指向該循環鏈表的第一個結點或者表頭結點，從而構成一個環形的鏈。
循環鏈表的運算與單鏈表的運算基本一致。所不同的有以下幾點：
1、在建立一個循環鏈表時，必須使其最後一個結點的指針指向表頭結點，而不是象單鏈表那樣置為NULL.此種情況還使用於在最後一個結點後插入一個新的結點。
2、在判斷是否到表尾時，是判斷該結點鏈域的值是否是表頭結點，當鏈域值等於表頭指針時，說明已到表尾。而非象單鏈表那樣判斷鏈域值是否為NULL.
二、雙向鏈表
雙向鏈表其實是單鏈表的改進。
當我們對單鏈表進行操作時，有時你要對某個結點的直接前驅進行操作時，又必須從表頭開始查找。這是由單鏈表結點的結構所限制的。因為單鏈表每個結點只有一個存儲直接後繼結點地址的鏈域，那麼能不能定義一個既有存儲直接後繼結點地址的鏈域，又有存儲直接前驅結點地址的鏈域的這樣一個雙鏈域結點結構呢？這就是雙向鏈表。
在雙向鏈表中，結點除含有數據域外，還有兩個鏈域，一個存儲直接後繼結點地址，一般稱之為右鏈域；一個存儲直接前驅結點地址，一般稱之為左鏈域。
❼ 關於C語言版數據結構中的單循環鏈表
void showlist(linklist head){//遍歷輸出鏈表
listnode *p;
p=head;
if(p->next=head){//這行里的p->next=head應寫成p->next==head
printf("list is empty!\n");
return;
}
else{
while((p=p->next)!=head){
printf("%d ",p->data);
}
}
}
❽ C語言數據結構中有尾指針的單循環鏈表
單循環鏈表實現隊列的出列操作的復雜度過高，因此推薦用帶頭指針的雙向循環鏈表實現隊列操作。
❾ C語言數據結構 如何建立單向循環鏈表並且輸入值
#include<iostream>
usingnamespacestd;
typedefcharElemType;
typedefintStatus;
#defineOK1
#defineERROR0
typedefstructLnode
{
ElemTypedata;
structLnode*next;
}Lnode,*LinkList;
voidCreat_List(LinkListL)//創建單鏈表並輸入元素
{
LinkListp,q;
q=L;
charch;
cout<<"請輸入鏈表元素,並且以輸入#表示結束!"<<endl;
while(cin>>ch&&ch!='#')
{
p=newLnode[sizeof(Lnode)];
if(!p)
{
cout<<"獲取內存失敗"<<endl;
exit(ERROR);
}
p->data=ch;//尾插法
L->next=p;
L=p;
}
L->next=q;
}
voidoutput_List(LinkListL)//遍歷單鏈表（輸出單鏈表元素)
{
LinkListp;
p=L->next;
if(p==L)
{
cout<<"該鏈表是空鏈表!"<<endl;
exit(ERROR);
}
while(p!=L)
{
cout<<p->data<<"";
p=p->next;
}
}
Statusmain()
{
LinkListH;
H=(LinkList)malloc(sizeof(Lnode));
H->next=NULL;//設置頭結點為空
Creat_List(H);
output_List(H);
return0;
}//頭結點有和沒有都是可以的，頭結點只是為了讓操作鏈表更方便，