❶ 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;
}//头结点有和没有都是可以的，头结点只是为了让操作链表更方便，