编程实现1到100累加和：循环结构详解-牛站云

1到100的累加和是编程学习中非常经典的基础案例。它看似简单，却能够完整体现变量定义、循环控制、条件判断以及累加计算等核心编程思想。通过这个例子，可以直观理解循环结构是如何重复执行一段代码，并逐步得到最终结果的。

一、1到100累加和是多少

所谓1到100累加和，就是计算：


1 + 2 + 3 + ... + 98 + 99 + 100

最终结果为：

除了直接使用数学公式，还可以通过程序让计算机逐个完成加法：


1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
...
5049 + 100 = 5050

这种“重复执行相同操作”的任务，非常适合使用循环结构实现。

二、使用循环实现1到100累加

实现累加最常见的思路是准备一个变量保存当前总和，然后使用循环让数字从1逐渐增加到100。

以C语言为例：

C
#include 

int main() {
    int sum = 0;

    for (int i = 1; i <= 100; i++) {
        sum += i;
    }

    printf("1到100的累加和为：%d
", sum);

    return 0;
}

运行结果：


1到100的累加和为：5050

这里最关键的代码是：

C
sum += i;

它等价于：

C
sum = sum + i;

每执行一次循环，就把当前的 i 加到 sum 中。

三、for循环的执行过程

for循环通常包含三个重要部分：

C
for (初始化; 条件; 更新) {
    // 循环体
}

对应到1到100累加程序：

C
for (int i = 1; i <= 100; i++) {
    sum += i;
}

可以拆分为：

int i = 1：设置循环变量初始值为1。
i <= 100：只要 i 不超过100，就继续循环。
i++：每次循环结束后，让 i 增加1。
sum += i：将当前数字加入总和。

程序的执行过程可以简单理解为：


sum = 0
i = 1 → sum = 1
i = 2 → sum = 3
i = 3 → sum = 6
i = 4 → sum = 10
...
i = 100 → sum = 5050

当执行完 i = 100 这一轮后，i++ 会让它变成101。此时条件 i <= 100 不成立，循环结束。

四、使用while循环实现累加

除了for循环，while同样可以完成1到100的累加：

C
#include 

int main() {
    int i = 1;
    int sum = 0;

    while (i <= 100) {
        sum += i;
        i++;
    }

    printf("1到100的累加和为：%d
", sum);

    return 0;
}

while循环的特点是先判断条件，再决定是否执行循环体。

核心逻辑为：

C
while (i <= 100) {
    sum += i;
    i++;
}

其中：

C
sum += i;

负责累加，而：

C
i++;

负责推进循环。

如果遗漏i++，i将始终保持为1，条件一直成立，程序就会进入无限循环。因此，使用while实现累加时，需要特别注意循环变量必须能够发生变化。

五、使用do...while循环实现

do...while与while的区别在于，它会先执行一次循环体，再判断条件。

示例代码：

C
#include 

int main() {
    int i = 1;
    int sum = 0;

    do {
        sum += i;
        i++;
    } while (i <= 100);

    printf("1到100的累加和为：%d
", sum);

    return 0;
}

程序同样输出：


1到100的累加和为：5050

对于“从1循环到100”这种明确知道循环次数的问题，for通常更加直观；如果循环结束条件更加动态，while往往更容易表达程序逻辑。

六、Python实现1到100累加和

Python的循环语法更加简洁：

Python
运行
total = 0

for i in range(1, 101):
    total += i

print("1到100的累加和为：", total)

输出：


1到100的累加和为： 5050

这里需要注意：

Python
运行
range(1, 101)

产生的是从1开始、到101之前结束的整数序列，也就是：


1, 2, 3, ..., 99, 100

因此Python中实现1到100循环时，通常写成：

Python
运行
range(1, 101)

而不是：

Python
运行
range(1, 100)

后者只会循环到99。

七、Java实现1到100累加和

Java中可以使用传统的for循环：

Java
public class Main {
    public static void main(String[] args) {
        int sum = 0;

        for (int i = 1; i <= 100; i++) {
            sum += i;
        }

        System.out.println("1到100的累加和为：" + sum);
    }
}

执行后得到：


1到100的累加和为：5050

Java中的实现与C语言非常接近，核心依然是“初始化总和变量—循环遍历数字—逐次累加”。

八、JavaScript实现1到100累加和

JavaScript代码如下：

JavaScript
let sum = 0;

for (let i = 1; i <= 100; i++) {
    sum += i;
}

console.log("1到100的累加和为：" + sum);

输出：


1到100的累加和为：5050

如果使用现代JavaScript，也可以结合数组方法实现，但对于学习循环结构而言，传统for循环更容易观察累加过程。

九、累加程序中的核心变量

1到100累加程序虽然只有几行代码，但其中包含两个非常重要的变量。

1. 循环变量

例如：

C
int i = 1;

i负责记录当前正在处理的数字。

它的变化过程是：


1 → 2 → 3 → 4 → ... → 100

2. 累加变量

例如：

C
int sum = 0;

sum用于保存已经计算出来的总和。

它会不断发生变化：

因此可以把整个程序抽象为：


循环变量负责“走”
累加变量负责“记”

这也是许多循环计算问题的基本模式。

十、为什么sum必须初始化为0

下面的写法是正确的：

C
int sum = 0;

因为累加的初始值是0。

如果没有初始化，例如：

C
int sum;

for (int i = 1; i <= 100; i++) {
    sum += i;
}

那么sum可能包含一个不确定的初始值，最终计算结果也就无法保证正确。

对于累加问题，一般遵循这样的初始化原则：


求和 → 初始值通常为0
求积 → 初始值通常为1

例如计算1到5的乘积：

C
int result = 1;

for (int i = 1; i <= 5; i++) {
    result *= i;
}

这里就不能将乘积变量初始化为0，否则任何数字乘以0都会得到0。

十一、如何避免循环边界错误

循环边界是实现累加程序时最容易出错的地方之一。

例如：

C
for (int i = 1; i < 100; i++)

只会计算：


1 + 2 + ... + 99

结果是：

而：

C
for (int i = 1; i <= 100; i++)

才会包含100，最终得到：

因此，在编写循环时，应明确判断条件到底是“小于”还是“小于等于”。

一个简单的检查方法是观察首尾两个值：


起始值：1
结束值：100

然后确认程序是否真的执行到了100。

十二、使用数学公式计算1到100的和

对于连续整数的累加，也可以使用高斯求和公式：


S = n × (n + 1) ÷ 2

当n = 100时：


S = 100 × 101 ÷ 2
  = 5050

对应程序可以写成：

C
int n = 100;
int sum = n * (n + 1) / 2;

这种方法不需要循环，直接就能得到结果。

不过，如果学习重点是理解循环结构，那么循环实现仍然非常重要。公式解决的是“如何快速得到结果”，而循环解决的是“如何让程序重复执行计算过程”。

十三、循环累加的通用写法

把固定的1到100扩展为任意范围，可以设计一个通用的累加程序：

C
int sum = 0;

for (int i = start; i <= end; i++) {
    sum += i;
}

例如计算1到1000：

C
int sum = 0;

for (int i = 1; i <= 1000; i++) {
    sum += i;
}

如果要计算50到100：

C
int sum = 0;

for (int i = 50; i <= 100; i++) {
    sum += i;
}

这种写法比把每个数字手动写出来更加灵活，也体现了循环结构在实际编程中的价值。

十四、循环结构中的常见错误

1. 初始值设置错误

C
for (int i = 0; i <= 100; i++)

这会把0也参与计算。虽然对最终结果没有影响，但它已经不是严格意义上的“从1到100遍历”。

2. 结束条件错误

C
for (int i = 1; i < 100; i++)

这种写法遗漏了100。

3. 忘记更新循环变量

C
while (i <= 100) {
    sum += i;
}

由于i没有变化，会造成无限循环。

正确写法应该包含：

C
i++;

4. 累加变量放错位置

正确方式：

C
for (int i = 1; i <= 100; i++) {
    sum += i;
}

如果把累加操作放在循环之外：

C
for (int i = 1; i <= 100; i++) {
}

sum += i;

不仅失去了循环累加的意义，还可能因为变量作用域问题导致程序无法编译。

十五、如何选择合适的循环结构

for、while和do...while都能够实现1到100累加，但适用场景有所不同。

循环结构	特点	适合场景
for	初始化、条件、更新集中	已知循环次数
while	根据条件决定是否执行	循环次数不确定
do...while	至少执行一次	必须先执行后判断
数学公式	不需要逐次循环	连续整数求和

对于1到100这种明确的计数问题，for循环通常最容易阅读和维护。

十六、进一步理解循环的价值

1到100累加并不是为了计算一个简单的5050，而是为了理解程序如何处理重复性任务。

假设需要计算：


1 + 2 + 3 + ... + 1000000

显然不可能手动写出一百万个数字。循环可以让程序自动完成这一过程：

C
long long sum = 0;

for (int i = 1; i <= 1000000; i++) {
    sum += i;
}

当数据规模进一步扩大时，还可以根据问题特点选择数学公式、递推算法或者其他更高效的方法。

因此，掌握“变量 + 循环 + 累加”这一基本模式后，可以继续学习数组遍历、统计数据、计算平均值、筛选数据以及嵌套循环等更复杂的程序设计问题。

十七、总结

实现1到100累加和的核心代码非常简单：

C
int sum = 0;

for (int i = 1; i <= 100; i++) {
    sum += i;
}