头歌c语言选择结构第一关排序

这道题目应该是要求使用选择结构对一组数字进行排序，下面是一个示例代码：

#include <stdio.h>

int main() {
    int a, b, c;
    printf("请输入三个整数：\n");
    scanf("%d %d %d", &a, &b, &c);
    if (a > b) {
        int temp = a;
        a = b;
        b = temp;
    }
    if (a > c) {
        int temp = a;
        a = c;
        c = temp;
    }
    if (b > c) {
        int temp = b;
        b = c;
        c = temp;
    }
    printf("排序后的结果为：%d %d %d\n", a, b, c);
    return 0;
}

代码思路：

1. 从标准输入中读入三个整数；

2. 使用选择结构（if语句）对三个数进行排序，具体方法是比较a与b、a与c、b与c的大小，将它们按照从小到大的顺序排列；

3. 输出排序后的结果。

注意事项：

1. 本代码只是一个示例，实际应用中需要根据实际需求进行修改；

2. 输入的三个数可以是任意整数，但是如果输入的数太大或太小，可能会导致溢出或意外错误；

3. 如果输入的三个数有相同的情况，本代码中没有进行特殊处理，实际应用中需要根据实际需求进行修改。

相关问题

头歌（C语言）-数据结构与算法-排序-第2关：实现快速排序

头歌（C语言）中的快速排序是一种高效的排序算法，它基于分治策略。以下是快速排序的基本步骤：

1. **选择基准**：通常选择数组的第一个元素作为基准值（pivot）。

2. **分区过程**：
- 将数组分为两部分：一部分包含所有小于基准值的元素，另一部分包含所有大于或等于基准值的元素。
- 这通常通过一趟从左到右的扫描完成，遇到比基准值小的数就交换到数组左边，遇到大的数则不动。

3. **递归排序**：
- 对左右两个分区分别进行快速排序，直到每个分区只剩下一个元素，此时视为已经排好序。

4. **合并结果**：最后将这三个已排序的部分合并成一个有序序列。

下面是快速排序的一个简单示例（使用了迭代法而非传统的递归形式以减少栈空间消耗）：

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

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 quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);

        quickSort(arr, low, pi - 1); // 递归处理左侧
        quickSort(arr, pi + 1, high); // 递归处理右侧
    }
}

// 示例
int main() {
    int arr[] = {9, 7, 5, 11, 12, 2, 14, 3};
    int n = sizeof(arr) / sizeof(arr[0]);

    quickSort(arr, 0, n - 1);
    
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

c语言实现第5关：拓扑排序

### C语言实现拓扑排序

在C语言中，可以通过邻接矩阵或邻接表来表示有向图，并基于此实现拓扑排序。下面展示一种常见的方法——Kahn算法的实现方式。

#### 定义必要的数据结构
为了方便操作，定义两个数组用于存储节点入度以及队列辅助处理当前无前驱结点（即入度为零）：

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

#define MAX_VERTICES 100 // 假设最多有MAX_VERTICES个顶点

// 邻接表中的边结构体
typedef struct EdgeNode {
    int adjvex;       // 边所指向的顶点位置
    struct EdgeNode *next;
}EdgeNode;

// 图的头结点(顶点)结构体
typedef struct VertexNode{
    char data;        // 存储顶点信息
    EdgeNode *firstedge;// 指向第一条依附于该顶点的边
}VertexNode, AdjList[MAX_VERTICES];

// 图结构体
typedef struct GraphAdjList{
    AdjList adjlist;
    int numNodes, numEdges;
}GraphAdjList;

int indegree[MAX_VERTICES]; // 记录各顶点的入度

#### 初始化图并读取输入
创建初始化函数`createGraph()`用来构建图实例化对象，并通过标准输入获取具体的图信息。

void createGraph(GraphAdjList *G){
    printf("请输入顶点数目和边的数量:\n");
    scanf("%d %d", &(G->numNodes), &(G->numEdges));
    
    for(int i=0;i<G->numNodes;++i){ 
        G->adjlist[i].data='A'+i; // 默认字符'A'开始编号
        G->adjlist[i].firstedge=NULL;
        indegree[i]=0;
    }

    EdgeNode* e;
    int start,end;
    for (int k = 0;k < G->numEdges ;k++) {  
        printf("请输入第%d条边的信息(start end):\n",k+1);
        scanf("%d %d",&start,&end);

        ++indegree[end];
        
        e=(EdgeNode*)malloc(sizeof(EdgeNode));   
        e->adjvex=end;
        e->next=G->adjlist[start].firstedge;
        G->adjlist[start].firstedge=e;
    }
}

#### Kahn算法的具体实现
核心逻辑在于不断移除入度为0的节点及其关联边，直至无法继续为止。

void topologicalSort(GraphAdjList *G){
    int queue[MAX_VERTICES], front=-1,rear=-1;
    int count=0,i,j,k,gettop;
    EdgeNode *p;

    // 将所有入度为0的顶点加入队列
    for(i=0;i<G->numNodes;i++)
      if(!indegree[i]) queue[++rear]=i;

    while(front!=rear){
        gettop=queue[++front];
        printf("%c ",G->adjlist[gettop].data); // 输出被删除的顶点
        
        p=G->adjlist[gettop].firstedge;
        while(p != NULL){
            j=p->adjvex;
            if(!(--indegree[j])) queue[++rear]=j;
            p=p->next;
        }
        ++count;
    } 

    if(count<G->numNodes) puts("\nThe graph has a cycle.");
    else                  puts("");
}

上述代码实现了完整的拓扑排序过程[^3]。当存在环时会给出提示信息；反之则按照顺序打印出各个顶点对应的字母标识符。