c语言实现各种排序算法（作业：点名册排序）

最新推荐文章于 2024-02-29 16:10:07 发布
最新推荐文章于 2024-02-29 16:10:07 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： 数据结构&&算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gz_jmark/article/details/7908403
版权

1.堆排序

#include <stdio.h>
struct sheet                                                     //结构体
{
    int number;
    char *name;         
};

void printer(sheet pupil[],int n)                                //打印点名册函数
{
    int k;
    for (k=0;k<n;k++)
    {
        printf("                     学号：%d,姓名：%s\n",pupil[k].number,pupil[k].name);
    }
    printf("\n");
}
void headadjust(sheet pupil[],int i,int j)                        //建堆函数 下标从0开始
{
    sheet temp = pupil[i];
    int k = 2*i+1;
    while (k<=j)
    {
        if (k<j&&pupil[k].number<pupil[k+1].number)
            k++;
        if (temp.number<pupil[k].number)
        {
            pupil[i] = pupil[k];
            i = k;
            k = 2*k+1;
        }
        else break;
    }
    pupil[i] = temp;
}

void headsort(sheet pupil[],int n)                                    // 堆排序算法函数
{
    int f=1;
    for(int i = n/2-1;i>=0;i--)
        headadjust(pupil,i,n-1);
    printf("初始建堆：\n");
    printer(pupil,8);//打印第一次堆建立
    for(i=n-1;i>0;i--)
    {
        sheet temp = pupil[0];
        pupil[0]=pupil[i];
        pupil[i] = temp;
        headadjust(pupil,0,i-1);    
        printf("第%d次调整堆:\n",f);
        f++;
        printer(pupil,8);//打印每次更新堆得内容    
    }
}
    
void main() 
{
    sheet pupil[8] = 
    {
        {120,"马海事"},
        {33,"黄广源"},
        {64,"梁伟"},
        {47,"老炳"},
        {11,"dota"},
        {550,"科比"},
        {310,"林书豪"},
        {16,"詹姆斯"}
    };
    printf("                   初始点名册为：\n");
    printer(pupil,8);
    headsort(pupil,8);
    printf("\n");
    printf("最终排序结果：\n");
    printer(pupil,8);
    getchar();
    getchar();
}
2.快速排序 

#include <stdio.h>
#define Max 20
struct sheet
{
    int number;
    char *name;         
};

//快速排序算法
void quicksort(sheet pupil[],int left,int right)
{
    int i,j;
    sheet swap;
    if(left < right)
    {
        i=left;
        j=right;
        swap = pupil[i];
        do 
        {
            while(pupil[j].number>swap.number&&i<j)
                j--;
            if (i<j)
            {
                pupil[i]=pupil[j];
                i++;
                
            }
            while(pupil[i].number<swap.number&&i<j)
                i++;
            if (i<j)
            {
                pupil[j]=pupil[i];
                j--;
            }
        } while (i!=j);
        pupil[i]=swap;
        quicksort(pupil,left,i-1);
        quicksort(pupil,i+1,right);
    }
    
}

//归并排序
void merge(sheet number[],int first,int last,int mid)
{
    sheet number_temp[Max];
    int i=first,j=mid+1,k;
    for(k=0;k<=last-first;k++)
    {
        if (i==mid+1)
        {
            number_temp[k]=number[j++];
            continue;
        }
        if (j==last+1)
        {
            number_temp[k]=number[i++];
            continue;
        }
        if (number[i].number<number[j].number)  
            number_temp[k]=number[i++];
        else  
            number_temp[k]=number[j++];
    }
    for (i=first,j=0;i<=last;i++,j++)
        number[i] = number_temp[j];
}

void merge_sort(sheet number[],int first,int last)
{
    int mid=0;
    if(first<last)
    {
        mid=(first+last)/2;
        merge_sort(number,first,mid);
        merge_sort(number,mid+1,last);
        merge(number,first,last,mid);
    }
}



//折半查找算法
int BinarySearch(sheet pupil[], int length, int key)
{
    int low = 0;
    int high = length - 1;
    while(low<=high)
    {
        int mid = (low+high)/2;
        if (key==pupil[mid].number) return mid;
            else 
                if (key<pupil[mid].number) high=mid -1;
                    else low=mid +1; 
    }
    return -1;
}

3.合并排序 

#include <stdio.h>
#include <malloc.h>
#include <iostream>
using namespace std;


struct sheet
{
    int number;
    char *name;         
};
void Merge(sheet rawArray[],int firstIndex,int middleIndex,int lastIndex)
{
    int firstArrayCount = middleIndex - firstIndex + 1;
    int secondArrayCount = lastIndex - middleIndex;
    
    sheet *firstArray = new sheet[firstArrayCount];
    sheet *secondArray = new sheet[secondArrayCount];
    int i=0;
    for ( i = 0; i < firstArrayCount; i++)
    {
        firstArray[i] = rawArray[firstIndex + i];
    }

    for ( i = 0; i < secondArrayCount; i++)
    {
        secondArray[i] = rawArray[middleIndex + i + 1];
    }
    
    int firstArrayIndex = 0;
    int secondArrayIndex = 0;
    int rawArrayIndex = firstIndex;
    while (firstArrayIndex < firstArrayCount && secondArrayIndex < secondArrayCount)
    {
        if (firstArray[firstArrayIndex].number <= secondArray[secondArrayIndex].number)
        {
            rawArray[rawArrayIndex++] = firstArray[firstArrayIndex++];
        }
        else
        {
            rawArray[rawArrayIndex++] = secondArray[secondArrayIndex++];
        }
    }
    while (firstArrayIndex < firstArrayCount)
    {
        rawArray[rawArrayIndex++] = firstArray[firstArrayIndex++];
    }
    
    while (secondArrayIndex < secondArrayCount)
    {
        rawArray[rawArrayIndex++] = secondArray[secondArrayCount++];
    } 
}


void MergeSort(sheet rawArray[],int firstIndex,int lastIndex)
{
    if (firstIndex < lastIndex)
    {
        int middleIndex = (firstIndex + lastIndex)/2; 
        MergeSort(rawArray, firstIndex, middleIndex);
        MergeSort(rawArray, middleIndex + 1, lastIndex);
        Merge(rawArray, firstIndex, middleIndex, lastIndex);
    }
}


void main() 
{
    sheet pupil[5] = 
    {
        {120,"ma"},
        {33,"pang"},
        {64,"weil"},
        {47,"tiantian"},
        {11,"wang"}
    };
    printf("初始点名册为：\n");
    int k;
    for (k=0;k<5;k++)
    {
        printf("学号：%d,姓名：%s\n",pupil[k].number,pupil[k].name);
    }
    MergeSort(pupil,0,4);
    //    quicksort(pupil,0,4);
    printf("排序后的点名册为：\n");
    for (k=0;k<5;k++)
    {
        printf("学号：%d,姓名：%s\n",pupil[k].number,pupil[k].name);
    }
    
    
}
4.选择和冒泡排序 

#include <stdio.h>
struct sheet
{
    int number;
    char *name;         
};



/*
void select_sort(sheet pupil[],int n)                              //这是插入排序
{
    int a;
    sheet swap;
    for (int i=1;i < n;i++)
    {
        for (int k=0;k < i;k++)
        {
            if (pupil[i].number <= pupil[k].number)
            {
                swap = pupil[i];
                a=k;
                while(a<i) 
                {
                    pupil[i]=pupil[i-1];
                    i--;
                }
                pupil[a] = swap;                
                break;
            }
        }
    }
}
*/

void select_sort(sheet pupil[],int n)
{
    int min=0;
    for (int i=0;i < n-1;i++)
    {
        min=i;
        for (int j = i+1;j < n;j++)
        {
            
            if (pupil[j].number < pupil[min].number)
            {
                min =j;
            }
        }
        
        sheet temp;
        temp = pupil[min];
        pupil[min] = pupil[i];
        pupil[i] = temp; 
    //    swap(&pupil[min],&pupil[i]);
    }
}

void bubble_sort(sheet pupil[],int n) 
{
    sheet temp;
    for (int k=n;k>0;k--)
    {
        for (int i=0; i< k ;i++)
        {
            if (pupil[i].number>pupil[i+1].number)
            {
                temp = pupil[i+1];
                pupil[i+1] = pupil[i];
                pupil[i] = temp; 
            }
        }
    }        
}

int find(sheet pupil[],int n,int k) 
{
    for (int i=0;i<n;i++)
    {
        if (pupil[i].number==k)
        {
            return i;
        }
    }
    return -1;
}

5.拓扑排序 

#include <iostream>
#include <stdlib.h>

#define MAX_VERTEX_NUM 30   
#define STACK_INIT_SIZE 100  
#define STACKINCREMENT 10   
typedef char InfoType;
typedef char VertexType;
typedef int SElemType;
typedef enum{DG,DN,UDG,UDN}GraphKind;

typedef struct ArcNode{ 
    int adjvex; 
    struct ArcNode *nextarc; 
    InfoType *info; 
}ArcNode;
typedef struct VNode{   
    VertexType data; 
    ArcNode *firstarc; 
}VNode,AdjList[MAX_VERTEX_NUM];
typedef struct ALGraph{ 
    AdjList vertices;
    int vexnum, arcnum; 
    int kind;
}ALGraph;

typedef struct Stack{   
        SElemType *base;   
        SElemType *top;     
        int stacksize;       
}Stack;

int CreateGraph(ALGraph &g);    //建立图的邻接表 
int LocateVex(ALGraph g, char v);   //v在图的邻接表中的位置返回位置i 
int FindInDegree(ALGraph g, int indegree[]);    //查找每个顶点结点的入度 
void TopologicalSort(ALGraph g);                //减一法实现的拓扑排序 
int InitStack(Stack &s);                        //初始化栈 
int Push(Stack &s, SElemType e);                //入栈 
int Pop(Stack &s,SElemType &e);                 //出栈 
int StackEmpty(Stack s);                        //判断是否是空栈 

int main(){
    int i;
    ALGraph g;
    CreateGraph(g);
    TopologicalSort(g); 
    system("pause");
    return 0;
}
/

int CreateGraph(ALGraph &g){
     FILE *fp;
     char fileName[20];
     printf("输入图形数据文件名:\n");
     scanf("%s",fileName);
     if((fp=fopen(fileName,"r+"))==NULL){       //读取文件Graph.txt中存储的图信息 
          printf("无法打开文件\n");
          printf("按任意键退出\n");
          getchar();getchar();
          exit(0);                                    
    }
     
     fscanf(fp,"%d %d",&g.vexnum,&g.arcnum);    //读结点数和弧数 
     int i,j,k;
     char v1,v2,ch1,ch2;
     getchar();
     //printf("%d %d\n",g.vexnum,g.arcnum);
     fgetc(fp);//吃回车 
     for(i=0;i<g.vexnum;i++){
         fscanf(fp,"%c",&g.vertices[i].data);   //建立结点数据 
         fgetc(fp);//吃空格    //getchar();
         g.vertices[i].firstarc = NULL;
     }
     
     for(j=0;j<g.arcnum;j++){       //存储弧信息 
         fscanf(fp,"%c%c%c%c",&v1,&ch1,&ch2,&v2);//getchar();
         fgetc(fp);//吃回车
         //printf("v1=%c,v2=%c\n",v1,v2);
         i = LocateVex(g,v1);
         k = LocateVex(g,v2);
         if(i==-1 || k==-1) {
            if(i==-1) printf("不存在结点%c的值\n",v1);
            if(k==-1) printf("不存在结点%c的值\n",v2);
            system("pause");
            exit(-2);       
         }
        
         ArcNode *p = (ArcNode *)malloc(sizeof(ArcNode)); 
         p->adjvex = k;                 //倒序建立弧链表 
         p->nextarc = g.vertices[i].firstarc;
         g.vertices[i].firstarc = p;
  
     }
 
     return 0;
}



int LocateVex(ALGraph g, char v){   //
     int i;
     for(i=0;i<g.vexnum;i++){
         if(g.vertices[i].data==v) break;
     }
     if(i<g.vexnum) return i;
     return -1;
}

void TopologicalSort(ALGraph g){
        int i,j,indegree[MAX_VERTEX_NUM]={0};
        int count=0;
        ArcNode *w = (ArcNode *)malloc(sizeof(ArcNode));
        FindInDegree(g,indegree);   //查找结点入度,存放到数据indegree中 
        
        //for(int o=0;o<g.vexnum;o++){
        //    printf("%d\n",indegree[o]);    
        //}
        Stack s;
        InitStack(s);
        for(i=0;i<g.vexnum;i++){
             if(indegree[i]==0) {
                    Push(s,i);
             }                        
        }
        //system("pause");
        printf("拓扑排序序列：");
        while(!StackEmpty(s)){
              Pop(s,i);
              printf("%c ",g.vertices[i].data);
              count++;
              for(w=g.vertices[i].firstarc;w;w=w->nextarc){
                   j = w->adjvex;
                   indegree[j]--;
                   if(indegree[j]==0) Push(s,j);
              }                      
        }
        
        printf("\n");
        if(count<g.vexnum) printf("输入的图存在环，拓扑排序无解！\n");
}

int InitStack(Stack &s){
        s.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
        if(!s.base) exit(-2); //分配出错，溢出
        s.top = s.base;
        s.stacksize = STACK_INIT_SIZE;
        return 1;
}

int Push(Stack &s, SElemType e){
        if(s.top-s.base >= s.stacksize){
             s.base = (SElemType *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(SElemType));
             if(!s.base) exit(-2);
             s.top = s.base + s.stacksize;
             s.stacksize += STACKINCREMENT;              
        }
        *s.top = e;
        s.top++;
        return 1;
}

int Pop(Stack &s,SElemType &e){
        if(s.top==s.base) return 0;
        s.top--;
        e = *s.top;
        return 1;
}

int StackEmpty(Stack s){
        if(s.top==s.base) return 1;
        else return 0;
}

int FindInDegree(ALGraph g, int indegree[]){
        int i;
        ArcNode *w = (ArcNode *)malloc(sizeof(ArcNode));
        for(i=0;i<g.vexnum;i++){
              for(w=g.vertices[i].firstarc;w;w=w->nextarc){
                     indegree[w->adjvex]++;                                             
              }                        
        }        
}

graph.txt

6 7
a b c d e f
a->c
b->c
c->d
c->e
d->e
a->f
f->b

Jmark_GC
关注
专栏目录
【C语言】案例四十六 点名册（一）
yusihe的博客
08-26 409
案例描述 案例要求编程实现一份基于指针的点名册，记录学生的姓名，并能实现学生姓名的输出；点名册中的学生姓名由多个字符组成，点名册中包含不止一名学生。 案例分析 将每个学生视为一个字符数组，则点名册中的内容可以视为多个字符数组的集合。如若每个学生姓名字节数都相同，那么点名册可以视为一个二维数组，但实际上，学生姓名字节可能各不相同。所以，需要考虑的问题有两个： 如何使用不同长度的字符数组存储学生的姓名 如何将多个存储学生姓名且长度不同的字符数组联系起来，使之成为一个整体 考虑到学生姓名逐条储存，类似于二维数组
【C语言】案例四十六 点名册（二）【strcpy（）函数】
yusihe的博客
08-26 351
案例实现 点名册中每个学生姓名都可以定义为一个字符数组，为了能统一操作点名册中的学生姓名，应使用指针数组，使数组中的每个指针都指向一个学生姓名。同时可以定义一个二级指针（数组指针），使该指针指向指针数组，使用二级指针读取点名册中的学生姓名。 完整代码 #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char buf[1024]; //普通数组，存储学生姓
【C语言】【新手易看懂的十大排序代码集】个人作业
feirangouyu的博客
04-11 211
以下是小白我翻看了n条大佬写的帖子，与《大话数据结构》这本书上的一些排序讲解，在几个与月同在的夜晚，滴干了眼药水（蛤蛤狗头警告）在本人的思路上肝出来的排序代码集，经测试无误才水帖上来（bug：你负责运行 我负责打脸）有错误欢迎指出哦。 代码如下 #include <stdio.h> #include <stdlib.h> #include <time.h> #d...
初学c语言系列之排序练习题1
weixin_44868393的博客
05-02 760
题目描述 查找和排序 题目：输入任意（用户，成绩）序列，可以获得成绩从高到低或从低到高的排列,相同成绩 都按先录入排列在前的规则处理。 示例： jack 70 peter 96 Tom 70 smith 67 从高到低 成绩 peter 96 jack 70 Tom 70 smith 67 从低到高 smith ...
C语言作业-advance7-1-排序
WAE86
07-10 408
#include #include int main(void) { int *a,n,number; int i,j,temp; scanf("%d",&n); a=(int *)malloc(sizeof(int)*n); //动态申请存储空间 for(i=0;i<n;i++) { scanf("%d",&number); a[i]=number; } for(i=0
C语言实现各类排序算法
ZHAOJUNWEI08的专栏
02-29 693
排序算法是计算机科学中的一个重要概念,它是一种将一个无序的数列重新排列成有序的方法。
各种排序算法，用C语言实现
clownote
08-23 211
你心爱的各种排序算法，用 C 语言实现。 我们下面将要实现的算法，全部准循这个接口： // sort 对数组 A 的前 n 个元素进行原址排序 typedef void (*sort)(int A[], int n); 直接插入排序 遍历，往前找到合适的位置，逐个元素后移腾出空间，插入进去。 复杂度： 时间 O(n2)O(n^2)O(n2) 空间 O(1)O(1)O(1) void insert_sort(int A[], int n) { for (int i = 0; i < n;
C语言实现各种排序算法实例
01-05
本文将深入探讨C语言实现的几种常见排序算法：冒泡排序、快速排序、直接插入排序、堆排序、希尔排序和归并排序。 1. **冒泡排序**： 冒泡排序是一种简单的交换排序，通过不断比较相邻元素并交换位置，使得每一轮...
C语言实现十大排序算法.rar
11-21
在编程领域，排序算法是计算机科学的基础之一，它在数据处理和数据分析中起着至关...通过学习这些排序算法的C语言实现，可以深入理解各种排序方法的工作原理，提高编程能力，并有助于在实际问题中选择合适的排序算法。
排序算法-基于C语言实现的排序算法之BogoSort实现.zip
最新发布
03-27
在C语言中实现排序算法，可以让开发者更深入地理解底层计算机制，同时也能提高代码执行效率。 **BogoSort算法** BogoSort，也被称为BozoSort或StoogeSort，是一种极其低效的排序算法，其主要思想是不断随机打乱...
随机点名册，c#代码编写
10-10
这是一个基于c#代码的简单点名册，讲excel中点名册导出来，然后点击点名就可以随机抽取同学
点名册.exe
12-16
点名 随机点名 这是一个随机点名的工具
C语言练习之排序算法：插入排序
01-16
在初学C语言时，比较重要的知识点就是排序算法，这里提供了一种插入排序算法的实现路径，供广大学习者参考。
C语言练习之排序算法：选择排序
01-16
在初学C语言时，比较重要的知识点就是排序算法，这里提供了一种选择排序算法的实现路径，供广大学习者参考。
educoder--实现快速排序
weixin_52563520的博客
12-11 814
任务描述 本关要求通过补全快速排序私有函数QSort__来供函数QuickSort调用，以此来实现快速排序的功能。 相关知识 快速排序的基本过程是：从待排序记录中任选一个记录，以它的排序码作为中心值，将其它记录划分为两个部分，第一部分包含所有排序码小于等于中心值的记录，第二部分包含所有排序码大于中心值的记录。第一部分放在该记录的前面，第二部分放在该记录的后面。对这两个部分采用同样的方法进行处理，直到每个部分为空或只含一个记录为止。 下图 1 给出了一个用中心值将排序记录分割为前后两部分的示例过程。
头歌（C语言）-数据结构与算法-排序-第1关：实现直接插入排序
weixin_59436900的博客
05-03 3249
先将第一个记录看作是一个有序的记录序列，然后从第二个记录开始，依次将未排序的记录插入到这个有序的记录序列中去，直到整个文件中的全部记录排序完毕。本关的编程任务是补全 step1/direcInsSort.cpp 文件中的。为了讨论简单，假设待排序的每个记录是一个整数，这个整数就是排序码。以上内容仅供参考哟，大家还需独立完成，巩固知识点^-^函数，按照从小到大的排列顺序实现直接插入排序。后面的记录是待排序的。来实现直接插入排序的功能。个整数从小到大排序的结果。： 首先输入一个正整数。中的序列是有序序列，
点名册（随机语音点名）
weixin_41905935的博客
07-08 1343
&lt;!DOCTYPE html&gt;&lt;html lang="en"&gt;&lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;meta name="viewport" content="width=device-width, initial-scale=1.0"&gt; &lt;met
用C语言实现常见的几个排序方法
热门推荐
写自己的代码，让别人去看吧
11-20 1万+
//排序方法通过 （函数调用） 的方式实现 //(1)直接插入排序 /* #include #define N 100 void Insertsort(int data[],int n)  //实现插入排序方法： { int i,j,temp; for(i=1;i { /* if(data[i] { data[0]=data[i]; data[i]=data
数据结构和算法绪论（三）
bangche3676的博客
11-03 110
1、线性表 什么是线性表? 例如：按照学号排序的班级花名册，同一个学号不可能有2名相同的同学； 什么是抽象数据类型？ int 、float、char等这种相同类型的数据集合整合在一块称之为抽象数据类型； 什么是线性表的抽象数据类型？ 什么是线性表的顺序存储结构？ 插入操作、删除操作； 什么是线性表链式存储结构？ 元素+指针（指向下一个元素的） 头指针、头节点 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值