将一个整数倒置

#include <stdio.h>
int main(void)
{
    int number = 233; //目标数字
    int sum = 0; //用于存放倒置后的数字
    int temp = 0; //用于临时存储number的值
    temp = number;  
    while(temp != 0)
    {
        sum = sum * 10 + temp % 10; //temp对10取余是为了得到个位数字
        temp /= 10; //为了下一次循环能获取到下一位数字
    }
    printf("%d",sum); //循环完成后sum即为number倒置后的数字
    return 0;
}

求斐波那契数列中任何一项的值

#include <stdio.h>
int main(void)
{
    int number; //指定要访问斐波那契数列中的哪一项
    int f1 = 1; //斐波那契数列中默认的第一项的值
    int f2 = 1; //斐波那契数列中默认的第二项的值
    int f3 = 2; //斐波那契数列中默认的第三项的值
    printf("请输入你要访问斐波那契数列中的哪一项");
    scanf("%d", &number);
    if (number == 1)
    {
        printf("%d", f1);
    }
    else if (number == 2)
    {
        printf("%d", f2);
    }
    else
    {
        for (int i = 3; i <= number; i++)
        {
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        printf("%d", f3);
    }
    return 0;
}

求一个数字是否是质数（素数）

#include <stdio.h>
bool IsPrime(int val)
{
    int i;
    for (i = 2; i < val; i++) //从2开始循环到目标数字本身，检查目标数字能否被中间的数字整除
    {
        if (val % i == 0)
        {
            break;
        }
    }
    if (val == i) //如果i与val的值一致，说明循环没有中途被break终止，即val是质数
    {
        return true;
    }
    else
    {
        return false;
    }
}
int main(void)
{
    bool prime = IsPrime(233);
    return 0;
}

选择排序

#include <stdio.h>
void Sort_Array(int* pArr, int length)
{
    int temp;
    for (int i = 0; i < length-1; i++)
    {
        for (int j = i+1; j < length; j++)
        {
            if (pArr[i] > pArr[j]) //升序排列
            {
                temp = pArr[i];
                pArr[i] = pArr[j];
                pArr[j] = temp;
            }
        }
    }
}
int main(void)
{
    int arr[5] = {5, 4, 3, 2, 1};
    Sort_Array(arr, 5);
    return 0;
}

冒泡排序

#include <stdio.h>
void Sort_Array(int* pArr, int length)
{
    int temp;
    for (int i = 0; i < length-1; i++)
    {
        for    (int j = 0; j < length-1-i; j++)
        {
            if (pArr[j] > pArr[j+1]) //升序排列
            {
                temp = pArr[j];
                pArr[j] = pArr[j+1];
                pArr[j+1] = temp;
            }
        }
    }
}
int main(void)
{
    int arr[5] = {5, 4, 3, 2, 1};
    Sort_Array(arr, 5);
    return 0;
}

动态创建一个链表，并将链表遍历输出

#include <stdio.h>
#include <stdlib.h>
struct Node
{
    int data; //数据域
    struct Node* pNext; //指针域
};
struct Node* CreateList(void)
{
    int length; //存储链表节点数
    int value; //临时存储链表节点数据域的值
    struct Node* pHead = (struct Node*)malloc(sizeof(struct Node)); //动态创建一个节点，将其地址赋给头指针
    struct Node* pTail = pHead; //定义一个指向尾节点的指针，并将头指针的值赋给它，此时头节点和尾节点是同一个节点
    pTail->pNext = NULL; //将尾节点的指针域设为NULL
    printf("请输入您要创建有几个节点的链表：length = ");
    scanf("%d", &length);
    for (int i = 0; i < length; i++)
    {
        printf("请输入第%d个节点的值：value = ",i+1);
        scanf("%d", &value);
        struct Node* pNew = (struct Node*)malloc(sizeof(struct Node)); //动态创建一个新节点
        pNew->data = value;
        pNew->pNext = NULL; //在创建了一个新节点后，默认此节点的指针域为NULL
        pTail->pNext = pNew; //在第一次执行这条语句时，相当于将头节点的指针域指向了pNew
                             //在第n次执行这条语句时，相当于将第n-1次创建的节点的指针域指向了pNew
        pTail = pNew; //在创建了一个新节点后，默认此节点为新的尾节点
    }
    return pHead;
}
void TraverseList(struct Node* pHead)
{
    if (pHead->pNext == NULL)
    {
        printf("链表为空");
        return;
    }
    struct Node* p = pHead->pNext;
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
}
int main(void)
{
    struct Node* pHead; //创建一个头指针
    pHead = CreateList(); // 创建一个链表，并将头指针的值返回
    TraverseList(pHead); //遍历链表
    return 0;
}

链表的有关操作

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
//结构体声明
typedef struct Node
{
    int data;
    struct Node* pNext;
}NODE, * PNODE;
//函数声明
PNODE Create_List();
void Traverse_List(PNODE pHead);
bool IsEmpty_List(PNODE pHead);
int CalcuteLength_List(PNODE pHead);
void Sort_List(PNODE pHead);
bool Insert_List(PNODE pHead, int pos, int val);
bool Delete_List(PNODE pHead, int pos, int* deleteVal);
int main(void)
{
    int value;
    PNODE pHead = NULL;
    pHead = Create_List();
    printf("构造好的链表是：");
    Traverse_List(pHead);
    Sort_List(pHead);
    printf("排序后的链表为：");
    Traverse_List(pHead);
    if(Insert_List(pHead, 5, 233))
        Traverse_List(pHead);
    if(Delete_List(pHead, 5, &value))
        Traverse_List(pHead);
    return 0;
}
//函数定义
PNODE Create_List()
{
    int length; //用于存储链表的有效长度
    int value; //用于临时存储数据
    PNODE pHead = (PNODE)malloc(sizeof(NODE));
    PNODE pTail = pHead;
    pTail->pNext = NULL;
    printf("请输入您要创建的链表节点个数：");
    scanf("%d", &length);
    for (int i = 0; i < length; i++)
    {
        printf("请输入第%d个节点的值：", i + 1);
        scanf("%d", &value);
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        pNew->data = value;
        pNew->pNext = NULL;
        pTail->pNext = pNew;
        pTail = pNew;
    }
    return pHead;
}
void Traverse_List(PNODE pHead) //将链表遍历输出
{
    PNODE p = pHead->pNext;
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");
}
bool IsEmpty_List(PNODE pHead) //判断链表是否为空
{
    if (pHead->pNext == NULL)
    {
        return true;
    }
    else
    {
        return false;
    }
}
int CalcuteLength_List(PNODE pHead) //计算链表有效节点数
{
    int length = 0;
    PNODE p = pHead->pNext;
    while (p != NULL)
    {
        length++;
        p = p->pNext;
    }
    return length;
}
void Sort_List(PNODE pHead) //将链表升序排序
{
    int temp;
    for (PNODE p = pHead->pNext; p != NULL; p = p->pNext)
    {
        for (PNODE q = p->pNext; q != NULL; q = q->pNext)
        {
            if (p->data > q->data)
            {
                temp = p->data;
                p->data = q->data;
                q->data = temp;
            }
        }
    }
}
bool Insert_List(PNODE pHead, int pos, int val) //在链表的第pos个节点插入新节点
{
    int i;
    PNODE p = pHead;
    //利用 i<pos-1 控制 p=p->pNext 的循环次数，i可看作p在链表中指向第i个节点（头节点看作0），最终p指向目标节点的前一个节点
    for (i = 0; p != NULL && i < pos - 1; i++)
    {
        p = p->pNext;
    }
    if (i>pos-1 || p == NULL)
    {
        return false;
    }
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    pNew->data = val;
    pNew->pNext = p->pNext;
    p->pNext = pNew;
    printf("在第%d号节点前插入一个新节点，插入节点的数据域是：%d\n", pos, val);
    return true;
}
bool Delete_List(PNODE pHead, int pos, int* deleteVal) //将第pos个节点删除
{
    int i;
    PNODE p = pHead;
    for (i = 0; i < pos - 1 && p != NULL; i++)
    {
        p = p->pNext;
    }
    if (i > pos - 1 || p == NULL)
    {
        return false;
    }
    PNODE r = p->pNext;
    *deleteVal = r->data;
    p->pNext = p->pNext->pNext;
    free(r);
    r = NULL;
    printf("删除链表中的第%d号节点，删除节点中的数据域是：%d\n", pos, *deleteVal);
    return true;
}

汉诺塔

解决递归问题时一定要认真思考这个自定义函数本身解决的是什么问题！

#include <stdio.h>
void hanoi(int n, char A, char B, char C) //将n个盘子从A柱借助B柱移到C柱上
{
    /*
        汉诺塔问题的复杂度是2的n次方减1
        问题很复杂，但实际上解决问题的编码就只有三句
        伪算法：
        如果只有一个盘子，将该盘子从A柱直接移到C柱
        如果有n个盘子(n>1)，分为三步：
            Step1、将n-1个盘子从A柱借助C柱移到B柱上
            Step2、将第n个盘子从A柱直接移到C柱上
            Step3、将n-1个盘子从B柱借助A柱移到C柱上
    */
    if (n == 1)
    {
        printf("将编号为%d的盘子从%c柱子移到%c柱子上\n", n, A, C);
    }
    else
    {
        hanoi(n - 1, A, C, B);
        printf("将编号为%d的盘子从%c柱子移到%c柱子上\n", n, A, C);
        hanoi(n - 1, B, A, C);
    }
}
int main(void)
{
    hanoi(4, 'A', 'B', 'C');
    return 0;
}

编程相关

C语言实现一些算法

将一个整数倒置

求斐波那契数列中任何一项的值

求一个数字是否是质数（素数）

选择排序

冒泡排序

动态创建一个链表，并将链表遍历输出

链表的有关操作

汉诺塔