循环相关算法

直到型循环算法：
第一步：S←0；
第二步：I←1；
第三步：S←S+I；
第四步：I←I+1；
第五步：如果I不大于100，转第三步；否则，输出S.
相应的流程图如图甲所示.

当型循环算法如下：
S1令i←1,S←0
S2若i≤100成立，则执行S3；否则，输出S，结束算法
S3 S←S+i
S4 i←i+1，返回S2
相应的流程图如图乙所示.

5. 有关c语言中for循环语句的算法

main（）
{int i,j,x=0;
for(i=0;i<2;i++)
{x++;//a
for(j=0;j<=3;j++)
{ if(j%2) continue;
x++;//b
}
x++;//c
}
printf("x=%d\n",x);
}
顺序是abbcabbc

6. 当型循环结构的算法功能是什么

当型循环结构：在每次执行循环体前，对条件进行判断，当条件满足时，执行循环体，否则终止循环。直到型循环结构：在执行了一次循环体后，对条件进行判断，如果条件不满，就继续执行，知道条件满足终止循环。

7. 利用两种循环写出1+2+3+…+100的算法，并画出各自的流程图

直到型循环算法：

第一步：S←0；

第二步：I←1；

第三步：S←S+I；

第四步：I←I+1；

第五步：如果I不大于100，转第三步；否则，输出S。相应的流程图如图甲所示．当型循环算法如

下：S1令i←1，S←0S2 。

当型循环算法如下：

S1 令i←1,S←0

S2 若i≤100成立，则执行S3；否则，输出S，结束算法

S3 S←S+i

S4 i←i+1，返回S2

相应的流程图如图乙所示。

(7)循环相关算法扩展阅读

从1开始递增依次与从100开始递减、将两个数进行相加配对、有50组为101的数。

1+100=101，2+99=101······50+51=101。从1加到100有50组这样的数，所以50X101=5050。

等差数列求和公式：（1+100）*100/2=5050

8. 计算机算法中有几种常用的循环结构

1.冒泡排序：时间复杂度为O(n * n)

NSArray *array ;
int i ,j;
for(i = 0, i < array.count -1, i++)
{
for( j = i , j < array.count -1,j++){
if(array[i] > array[j]){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}

2.二分查找（折半查找），时间复杂度为o(log n )

int search(int array[], int low, int high, int target)
{
if (low > high) return -1;//第一次，low为0，high为数组的个数。这是用递归实现的。

int mid = (low + high)/2;
if (array[mid]> target)
return search(array, low, mid -1, target);
if (array[mid]< target)
return search(array, mid+1, high, target);

//if (midValue == target)
return mid;
}3.单链表反转

使用3个指针遍历单链表，逐个链接点进行反转。

ActList* ReverseList2(ActList* head)
{
//ActList* temp=new ActList;
if(NULL==head|| NULL==head->next) return head; //少于两个节点没有反转的必要。
ActList* p;
ActList* q;
ActList* r;
p = head;
q = head->next;
head->next = NULL; //旧的头指针是新的尾指针，next需要指向NULL
while(q){
r = q->next; //先保留下一个step要处理的指针
q->next = p; //然后p q交替工作进行反向
p = q;
q = r;
}
head=p; // 最后q必然指向NULL，所以返回了p作为新的头指针
return head;
}
4.判断一个链表是否为循环链表

判断一个单向链表是否是循环链表比较简单,只要将一个指针p指向表的第一个节点，而另外一个指针q指向
p的下一个节点，然后让q向后滑动，直到q为0或q等于p(此时表是循环链表)为止。
5.判断一个单链表是否存在环
设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。(当然，fast先行头到尾部为NULL，则为无环链表)程序如下：

bool IsExitsLoop(slist *head)
{
slist *slow = head, *fast = head;

while ( fast && fast->next )
{
slow = slow->next;
fast = fast->next->next;
if ( slow == fast ) break;
}

return !(fast == NULL || fast->next == NULL);
}

9. C# asp.net 的循环算法，求

不太明白你的要求
C# 循环的话一般就用for、foreach,while
for循环是这样
for(int i=0;i<10;i++)//这里就是从0到9，也就是循环10次
{
这里就是你要执行的代码
}
foreach循环的列子
string[] Name=new string[2];
Name[0]="guanyu";
Name[1]="zhangfei";
foreach(string n in Name )
{
你要执行的代码
}

while循环的列子
while(expression)//这里要返回bool值，如果是true才会执行下面的代码
{
你要执行的代码
}
而
do
{
你要执行的代码
}
while(expression)//这个跟上面不同的是，循环最少执行一次
而foreach大多是针对集合的或者数组的

10. 求循环队列的元素个数算法，已知front 和 rear，还有容量数，怎么求队列中的循环元素个数

如果是用数组实现的 用队尾减队头再模数组长度；如果是链表 就要有个计数变量了。

front为对头指针，rear为对尾指针，n为队列最大元素个数。队列元素个数=(rear-front+1+n)%n %是求余数。

循环队列的元素个数计算公式：

如果rear<front结果是rear-front+maxsize；

如果rear>front结果是rear-front；

为了用一个表达式同时表达两者，用(rear-front+maxsize)%maxsize；

假设maxsize=10；

rear=1 front=9，那么结果是2；

rear=9 front=1，那么结果是8。

(10)循环相关算法扩展阅读

循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成队空和队满时头尾指针均相等。因此，无法通过条件front==rear来判别队列是"空"还是"满"。

解决这个问题的方法至少有两种：

① 另设一布尔变量以区别队列的空和满；

②另一种方式就是数据结构常用的： 队满时：(rear+1)%n==front，n为队列长度（所用数组大小），由于rear，front均为所用空间的指针，循环只是逻辑上的循环，所以需要求余运算。

队已满，但是rear（5）+1=6！=front（0），对空间长度求余，作用就在此6%6=0=front（0）。