您当前的位置:首页 > 电脑百科 > 程序开发 > 语言 > C/C++/C#

C语言如何写出高效代码?8个高效代码案例赏析,绝对干货

时间:2023-06-20 15:27:54  来源:今日头条  作者:晓亮Albert

当涉及复杂的高效C代码案例时,这些代码示例展示了C语言中一些复杂且高效的应用案例,涵盖了排序算法、图算法、位操作、文件操作、多线程编程等领域。这些案例体现了C语言在各个领域的广泛应用和高效性,以下是8个经典的例子:

1.快速排序算法:

void quicksort(int arr[], int low, int high) {
    if (low < high) {
        int pivot = partition(arr, low, high);
        quicksort(arr, low, pivot - 1);
        quicksort(arr, pivot + 1, high);
    }
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] <= pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

这是经典的快速排序算法实现,采用分治思想,通过递归地将数组分成两部分并进行排序,从而实现快速的排序效果。

2.动态规划算法-最长公共子序列(Longest Common Subsequence):

int lcs(char* X, char* Y, int m, int n) {
    int L[m + 1][n + 1];
    for (int i = 0; i <= m; i++) {
        for (int j = 0; j <= n; j++) {
            if (i == 0 || j == 0)
                L[i][j] = 0;
            else if (X[i - 1] == Y[j - 1])
                L[i][j] = L[i - 1][j - 1] + 1;
            else
                L[i][j] = max(L[i - 1][j], L[i][j - 1]);
        }
    }
    return L[m][n];
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

这段代码实现了最长公共子序列问题的动态规划解法,通过构建一个二维数组,逐步计算最长公共子序列的长度。

3.哈夫曼编码(Huffman Coding):

struct MinHeapNode {
    char data;
    unsigned freq;
    struct MinHeapNode *left, *right;
};

struct MinHeap {
    unsigned size;
    unsigned capacity;
    struct MinHeapNode** array;
};

struct MinHeapNode* newNode(char data, unsigned freq) {
    struct MinHeapNode* temp =
        (struct MinHeapNode*)malloc(sizeof(struct MinHeapNode));
    temp->left = temp->right = NULL;
    temp->data = data;
    temp->freq = freq;
    return temp;
}

struct MinHeap* createMinHeap(unsigned capacity) {
    struct MinHeap* minHeap =
        (struct MinHeap*)malloc(sizeof(struct MinHeap));
    minHeap->size = 0;
    minHeap->capacity = capacity;
    minHeap->array =
        (struct MinHeapNode**)malloc(minHeap->capacity * 
                                     sizeof(struct MinHeapNode*));
    return minHeap;
}

void buildMinHeap(struct MinHeap* minHeap, int size) 
{ 
  int i; 
  for (i = (size - 1) / 2; i >= 0; --i) 
    minHeapify(minHeap, i); 
}

void minHeapify(struct MinHeap* minHeap, int idx) 
{ 
  int smallest = idx; 
  int left = 2 * idx + 1; 
  int right = 2 * idx + 2;
  if (left < minHeap->size && 
      minHeap->array[left]->freq < minHeap->array[smallest]->freq)
    smallest = left;

if (right < minHeap->size && 
    minHeap->array[right]->freq < minHeap->array[smallest]->freq)
    smallest = right;

if (smallest != idx) {
    swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]);
    minHeapify(minHeap, smallest);
}
}

void swapMinHeapNode(struct MinHeapNode** a, struct MinHeapNode** b)
{ struct MinHeapNode* t = *a; *a = *b; *b = t; }

int isSizeOne(struct MinHeap* minHeap) { return (minHeap->size == 1); }

struct MinHeapNode* extractMin(struct MinHeap* minHeap) { 
  struct MinHeapNode* temp = minHeap->array[0]; 
  minHeap->array[0] = minHeap->array[minHeap->size - 1]; 
  --minHeap->size; 
  minHeapify(minHeap, 0); 
  return temp; }

void insertMinHeap(struct MinHeap* minHeap, struct MinHeapNode* minHeapNode) 
{ 
  ++minHeap->size; 
  int i = minHeap->size - 1; 
  while (i && minHeapNode->freq < minHeap->array[(i - 1) / 2]->freq) 
  { 
    minHeap->array[i] = minHeap->array[(i - 1) / 2]; 
    i = (i - 1) / 2; 
  } 
  minHeap->array[i] = minHeapNode; 
}

void buildHuffmanTree(char data[], int freq[], int size) 
{ struct MinHeapNode* left, * right, * top; 
 struct MinHeap* minHeap = createMinHeap(size); 
 for (int i = 0; i < size; ++i) 
   minHeap->array[i] = newNode(data[i], freq[i]); 
 minHeap->size = size; 
 buildMinHeap(minHeap, size); 
 while (!isSizeOne(minHeap)) 
 { 
   left = extractMin(minHeap); 
   right = extractMin(minHeap); 
   top = newNode('$', left->freq + right->freq); 
   top->left = left; 
   top->right = right; 
   insertMinHeap(minHeap, top); 
 } 
 printCodes(minHeap->array[0], ""); 
}

void printCodes(struct MinHeapNode* root, char* str) 
{ 
  if (root == NULL) return; 
  if (root->data != '$') 
    printf("%c: %sn", root->data, str); 
  printCodes(root->left, strcat(str, "0")); 
  str[strlen(str) - 1] = ''; 
  printCodes(root->right, strcat(str, "1")); 
  str[strlen(str) - 1] = '';
}

 

这段代码实现了哈夫曼编码的算法,通过构建哈夫曼树并生成每个字符的编码。

4.图的深度优先搜索(Depth-First Search):

#define MAX_VERTICES 100

typedef struct {
    int data[MAX_VERTICES];
    int top;
} Stack;

void initStack(Stack* stack) {
    stack->top = -1;
}

void push(Stack* stack, int value) {
    stack->data[++stack->top] = value;
}

int pop(Stack* stack) {
    return stack->data[stack->top--];
}

int isEmpty(Stack* stack) {
    return stack->top == -1;
}

void dfs(int graph[MAX_VERTICES][MAX_VERTICES], int vertex, int visited[]) {
    Stack stack;
    initStack(&stack);
    push(&stack, vertex);
    visited[vertex] = 1;
    while (!isEmpty(&stack)) {
        int current = pop(&stack);
        printf("%d ", current);
        for (int i = 0; i < MAX_VERTICES; ++i) {
            if (graph[current][i] && !visited[i]) {
                push(&stack, i);
                visited[i] = 1;
            }
        }
    }
}

这段代码实现了图的深度优先搜索算法,使用栈数据结构来辅助遍历图的顶点,并通过访问数组来记录已访问的顶点。

5.最短路径算法-迪杰斯特拉算法(Dijkstra's Algorithm):

#define MAX_VERTICES 100
#define INF 9999

void dijkstra(int graph[MAX_VERTICES][MAX_VERTICES], int startVertex, int numVertices) {
    int dist[MAX_VERTICES];
    int visited[MAX_VERTICES];
    for (int i = 0; i < numVertices; ++i) {
        dist[i] = INF;
        visited[i] = 0;
    }
    dist[startVertex] = 0;
    for (int count = 0; count < numVertices - 1; ++count) {
        int u = minDistance(dist, visited, numVertices);
        visited[u] = 1;
        for (int v = 0; v < numVertices; ++v) {
            if (!visited[v] && graph[u][v] && dist[u] + graph[u][v] < dist[v]) {
                dist[v] = dist[u] + graph[u][v];
            }
        }
    }
    printDistances(dist, numVertices);
}

int minDistance(int dist[], int visited[], int numVertices) {
    int min = INF, minIndex;
    for (int v = 0; v < numVertices; ++v) {
        if (!visited[v] && dist[v] <= min) {
            min = dist[v];
            minIndex = v;
        }
    }
    return minIndex;
}

void printDistances(int dist[], int numVertices) {
    printf("VertextDistance from Start Vertexn");
    for (int i = 0; i < numVertices; ++i) {
        printf("%dt%dn", i, dist[i]);
    }
}

这段代码实现了迪杰斯特拉算法,用于求解带权重的图中从起始顶点到其他顶点的最短路径。

6.位操作-计算整数中1的个数:

int countSetBits(int n) {
    int count = 0;
    while (n)
    {
     if (n == 0) 
      return 0;
     else 
      return 1 + countSetBits(n & (n - 1));
    }
}

这段代码使用位操作技巧计算一个整数中包含的1的个数,通过不断将整数n与(n-1)进行按位与操作,直到n变为0,统计操作次数即为1的个数。

7.文件操作-统计文件中单词的个数:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LENGTH 100

int countwords(FILE* file) {
    int count = 0;
    char word[MAX_LENGTH];
    while (fscanf(file, "%s", word) != EOF) {
        count++;
    }
    return count;
}
int mAIn() {
    FILE* file = fopen("input.txt", "r");
    if (file == NULL) {
        printf("File not found.n");
        return 1;
    }
    int wordCount = countWords(file);
    printf("Number of words in the file: %dn", wordCount);
    fclose(file);
    return 0;
}

这段代码读取文件中的内容,按照空格分隔单词,并统计文件中单词的个数。

8.多线程编程-并行计算:

#include <stdio.h>
#include <pthread.h>

#define NUM_THREADS 4
#define ARRAY_SIZE 10000

int array[ARRAY_SIZE];
int sum = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* calculateSum(void* arg) {
    int threadID = *((int*)arg);
    int start = threadID * (ARRAY_SIZE / NUM_THREADS);
    int end = start + (ARRAY_SIZE / NUM_THREADS);
    int localSum = 0;
    for (int i = start; i < end; ++i) {
        localSum += array[i];
    }
    pthread_mutex_lock(&mutex);
    sum += localSum;
    pthread_mutex_unlock(&mutex);
    pthread_exit(NULL);
}

int main() {
    pthread_t threads[NUM_THREADS];
    int threadIDs[NUM_THREADS];

    for (int i = 0; i < ARRAY_SIZE; ++i) {
        array[i] = i + 1;
    }

    for (int i = 0; i < NUM_THREADS; ++i) {
        threadIDs[i] = i;
        pthread_create(&threads[i], NULL, calculateSum, (void*)&threadIDs[i]);
    }

    for (int i = 0; i < NUM_THREADS; ++i) {
        pthread_join(threads[i], NULL);
    }

    printf("Sum of array elements: %dn", sum);

    return 0;
}

这段代码使用多线程编程实现并行计算一个数组中元素的总和,通过将数组划分为多个部分,并分配给不同的线程进行计算,最后将各线程的计算结果累加得到最终的总和。



Tags:C语言   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,不构成投资建议。投资者据此操作,风险自担。如有任何标注错误或版权侵犯请与我们联系,我们将及时更正、删除。
▌相关推荐
C语言中的volatile:变量的易变性和内存访问的优化
概念:在C语言中,volatile是一个关键字,用于告诉编译器变量的值是易变的,可能会在意料之外的情况下发生改变,从而防止编译器对该变量的优化和缓存。volatile关键字用于修饰那些可...【详细内容】
2023-12-31  Search: C语言  点击:(64)  评论:(0)  加入收藏
C语言中的静态变量解析
一、引言在C语言中,变量的存储类别决定了变量在程序中的生命周期和可见性。静态变量是其中一种具有特殊属性的变量,它们在程序的执行过程中具有持久的生命周期,并且仅在其定义...【详细内容】
2023-12-29  Search: C语言  点击:(137)  评论:(0)  加入收藏
C语言变长参数及其陷阱
C 工具变长参数列表这部分解释了旧的 C 风格变长参数列表。了解这些内容很重要,因为你可能会在遗留代码中遇到它们。然而,在新代码中,你应该使用变参模板来实现类型安全的变长...【详细内容】
2023-12-15  Search: C语言  点击:(138)  评论:(0)  加入收藏
C语言代码:数字雨
在我们的日常生活中,雨水是我们经常遇到的一种自然现象。有时候,我们会在雨中漫步,欣赏那美丽的雨景。然而,在计算机世界里,我们如何用代码来模拟这种美丽的雨景呢?本文将通过一个...【详细内容】
2023-11-23  Search: C语言  点击:(155)  评论:(0)  加入收藏
拿捏C语言,就看这一篇!
嵌入式系统是我们日常生活中无处不在的一部分。从智能手机到家用电器,从汽车到医疗设备,嵌入式系统的应用范围广泛且不断增长。C语言是一种高效、简洁、灵活的编程语言,是嵌入...【详细内容】
2023-11-14  Search: C语言  点击:(221)  评论:(0)  加入收藏
Java为什么比C语言更加的受青睐?
Java和C语言都是广泛应用于软件开发领域的编程语言,然而Java在近年来越来越受到开发者的青睐。这主要归因于Java在以下几个方面的优势。跨平台性Java的跨平台性是其最显著的...【详细内容】
2023-11-09  Search: C语言  点击:(337)  评论:(0)  加入收藏
自学C语言,其最恐怖的地方是什么?
今天我们来聊聊关于自学C语言的事。首先得承认,这条路并不容易。学会C语言自学对很多人来说都是个不小的考验。这门编程语言的复杂性和一堆晦涩难懂的概念,让学习过程变得相当...【详细内容】
2023-11-03  Search: C语言  点击:(197)  评论:(0)  加入收藏
比C语言还快20%!Mojo首个大模型开放下载,性能达Python版250倍
明敏 发自 凹非寺量子位 公众号 | QbitAI专为AI而来的新语言Mojo,推理LLaMA2性能比Python提升250倍!比C语言也要快上20%。上周五才开放下载,Mojo这么快就自证实力了。要知道,之...【详细内容】
2023-09-13  Search: C语言  点击:(360)  评论:(0)  加入收藏
为什么C++无法彻底替代C语言?
随着时间的推移,编程语言的发展不断演进,新的工具和技术层出不穷。然而,在这个瞬息万变的编程世界中,有一对老朋友一直在默默地坚守着自己的位置:C 和 C++。这两门编程语言都拥有...【详细内容】
2023-09-11  Search: C语言  点击:(286)  评论:(0)  加入收藏
c语言中的预处理、宏、条件编译
在C程序中,以 # 开头的命令就是预处理命令,这些命令都是放在函数之外,而且一般都放在源文件的前面,如下面的两条命令:#include <stdio.h> #define PI 3.1415926宏可以看做是一些...【详细内容】
2023-09-08  Search: C语言  点击:(326)  评论:(0)  加入收藏
▌简易百科推荐
C++常见避坑指南
C++ 从入门到放弃?本文主要总结了在C++开发或review过程中常见易出错点做了归纳总结,希望借此能增进大家对C++的了解,减少编程出错,提升工作效率,也可以作为C++开发的避坑攻略。...【详细内容】
2024-04-03  腾讯技术工程    Tags:C++   点击:(4)  评论:(0)  加入收藏
C++ 之父反驳白宫警告:自诞生第一天起,C++ 的目标就一直是提高安全性
整理 | 郑丽媛上个月,美国白宫国家网络主任办公室(ONCD)在一份主题为《回到基础构件:通往安全软件之路》的 19 页 PDF 报告中,呼吁开发人员停止使用容易出现内存安全漏洞的编程语...【详细内容】
2024-03-25    CSDN  Tags:C++   点击:(4)  评论:(0)  加入收藏
八个 C++ 开源项目,帮助初学者进阶成长
通过参与或阅读开源项目的源代码,你可以获得丰富的实践机会。实际的项目代码比简单的教程更具挑战性,可以帮助你深入理解 C++ 的各种概念和技术。1.ThreadPool一个简单的 C++1...【详细内容】
2024-03-22  AI让生活更美好  微信公众号  Tags:C++   点击:(21)  评论:(0)  加入收藏
C# 中15个值得收藏的开源项目推荐
在开源的世界里,C# 编程语言也占有一席之地。这些开源项目涵盖了多个领域,从框架、库到工具,它们为C#开发者提供了丰富的资源和工具,帮助他们更高效地开发、测试和部署应用程序...【详细内容】
2024-03-20  程序员编程日记  微信公众号  Tags:C#   点击:(30)  评论:(0)  加入收藏
C#异步编程:Task.Run vs. async-await,掌握基础与高级用法
概述:C#中的异步编程有两主要方式:Task.Run用于在后台线程执行同步操作,而async-await更适用于清晰表达异步流程。基础用法展示了它们的简单应用,高级用法则演示了它们的结合使...【详细内容】
2024-03-09  架构师老卢  今日头条  Tags:C#   点击:(23)  评论:(0)  加入收藏
C++多线程编程:解锁性能与并发的奥秘
今天我们将深入探讨C++中的多线程编程,揭示多线程如何解锁性能潜力,提高程序的并发性能。什么是多线程?在计算机科学中,多线程是指一个进程(程序的执行实例)中的多个线程同时执行...【详细内容】
2024-02-03     AI让生活更美好  Tags:C++   点击:(69)  评论:(0)  加入收藏
C++代码优化攻略
今天我们将深入探讨C++性能优化的世界。在当今软件开发的浪潮中,高性能的代码是必不可少的。无论是开发桌面应用、移动应用,还是嵌入式系统,性能都是关键。1. 选择合适的数据结...【详细内容】
2024-01-26  AI让生活更美好  微信公众号  Tags:C++   点击:(114)  评论:(0)  加入收藏
C# 线程本地存储为什么线程间值不一样
为什么用 ThreadStatic 标记的字段,只有第一个线程拿到了初始值,其他线程都是默认值,让我能不能帮他解答一下,尼玛,我也不是神仙什么都懂,既然问了,那我试着帮他解答一下,也给后面类...【详细内容】
2024-01-26  一线码农聊技术  微信公众号  Tags:C#   点击:(67)  评论:(0)  加入收藏
C++质数检测器的设计与实现​
质数,作为数学中的一个基本概念,一直以其独特的性质吸引着众多研究者和爱好者。质数是指大于1的自然数中,除了1和它本身以外不再有其他因数的数。在实际应用中,质数检测也扮演着...【详细内容】
2024-01-15  鲨鱼编程  微信公众号  Tags:C++   点击:(111)  评论:(0)  加入收藏
C# 登顶!超越Java或非空想
整理丨诺亚出品 | 51CTO技术栈(微信号:blog51cto)近日,TIOBE编程社区公布年度编程语言,此次摘得这一桂冠的是C#。这也是C#在TIOBE二十多年评选历史中首次赢得这一年度大奖。C#虽...【详细内容】
2024-01-15    51CTO  Tags:C#   点击:(114)  评论:(0)  加入收藏
站内最新
站内热门
站内头条