C语言实现各种排序查找

最新推荐文章于 2023-12-19 21:08:19 发布
最新推荐文章于 2023-12-19 21:08:19 发布
阅读量617 收藏 5
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
原文链接：https://fantianzuo.blog.csdn.net/article/details/115587600
版权 
/* Note:Your choice is C IDE */
#include "stdio.h"
#include"stdlib.h"
#define MAX 10
void SequenceSearch(int *fp,int Length);
void Search(int *fp,int length);
void Sort(int *fp,int length);
/*
注意：
    1、数组名x,*(x+i)就是x[i]哦
*/
 
 
/*
================================================
功能:选择排序
输入:数组名称(数组首地址)、数组中元素个数
================================================
*/
void select_sort(int *x, int n)
{
    int i, j, min, t;
    for (i=0; i<n-1; i++) /*要选择的次数:下标：0~n-2，共n-1次*/
    {
        min = i; /*假设当前下标为i的数最小,比较后再调整*/
        for (j=i+1; j<n; j++)/*循环找出最小的数的下标是哪个*/
        {
            if (*(x+j) < *(x+min))
                min = j; /*如果后面的数比前面的小,则记下它的下标*/
        }
        if (min != i) /*如果min在循环中改变了,就需要交换数据*/
        {
            t = *(x+i);
            *(x+i) = *(x+min);
            *(x+min) = t;
        }
    }
}
/*
================================================
功能:直接插入排序
输入:数组名称(也就是数组首地址)、数组中元素个数
================================================
*/
 
void insert_sort(int *x, int n)
{
    int i, j, t;
    for (i=1; i<n; i++) /*要选择的次数:下标1~n-1，共n-1次*/
    {
        /*
         暂存下标为i的数。注意:下标从1开始,原因就是开始时
         第一个数即下标为0的数,前面没有任何数,认为它是排
         好顺序的。
        */
        t=*(x+i);
        for (j=i-1; j>=0 && t<*(x+j); j--) /*注意:j=i-1,j--,这里就是下标为i的数,在它前面有序列中找插入位置。*/
        {
            *(x+j+1) = *(x+j); /*如果满足条件就往后挪。最坏的情况就是t比下标为0的数都小,它要放在最前面,j==-1,退出循环*/
        }
        *(x+j+1) = t; /*找到下标为i的数的放置位置*/
    }
}
/*
================================================
功能:冒泡排序
输入:数组名称(也就是数组首地址)、数组中元素个数
================================================
*/
void bubble_sort0(int *x, int n)
{
    int j, h, t;
    for (h=0; h<n-1; h++)/*循环n-1次*/
    {
        for (j=0; j<n-2-h; j++)/*每次做的操作类似*/
        {
            if (*(x+j) > *(x+j+1)) /*大的放在后面,小的放到前面*/
            {
                t = *(x+j);
                *(x+j) = *(x+j+1);
                *(x+j+1) = t; /*完成交换*/
            }
        }
    }
}
/*优化：记录最后下沉位置，之后的肯定有序*/
void bubble_sort(int *x, int n)
{
    int j, k, h, t;
    for (h=n-1; h>0; h=k) /*循环到没有比较范围*/
    {
        for (j=0, k=0; j<h; j++) /*每次预置k=0,循环扫描后更新k*/
        {
            if (*(x+j) > *(x+j+1)) /*大的放在后面,小的放到前面*/
            {
                t = *(x+j);
                *(x+j) = *(x+j+1);
                *(x+j+1) = t; /*完成交换*/
                k = j; /*保存最后下沉的位置。这样k后面的都是排序排好了的。*/
            }
        }
    }
}
/*
================================================
功能:希尔排序
输入:数组名称(也就是数组首地址)、数组中元素个数
================================================
*/
 
void shell_sort(int *x, int n)
{
    int h, j, k, t;
    for (h=n/2; h>0; h=h/2) /*控制增量*/
    {
        for (j=h; j<n; j++) /*这个实际上就是上面的直接插入排序*/
        {
            t = *(x+j);
            for (k=j-h; (k>=0 && t<*(x+k)); k-=h)
            {
                *(x+k+h) = *(x+k);
            }
            *(x+k+h) = t;
        }
    }
}
/*
================================================
功能:快速排序
输入:数组名称(也就是数组首地址)、数组中起止元素的下标
注：自己画画
================================================
*/
 
void quick_sort(int *x, int low, int high)
{
    int i, j, t;
    if (low < high) /*要排序的元素起止下标,保证小的放在左边,大的放在右边。这里以下标为low的元素（最左边）为基准点*/
    {
        i = low;
        j = high;
        t = *(x+low); /*暂存基准点的数*/
        while (i<j) /*循环扫描*/
        {
            while (i<j && *(x+j)>t) /*在右边的只要比基准点大仍放在右边*/
            {
                j--; /*前移一个位置*/
            }
            if (i<j)
            {
                *(x+i) = *(x+j); /*上面的循环退出:即出现比基准点小的数,替换基准点的数*/
                i++; /*后移一个位置,并以此为基准点*/
            }
            while (i<j && *(x+i)<=t) /*在左边的只要小于等于基准点仍放在左边*/
            {
                i++; /*后移一个位置*/
            }
            if (i<j)
            {
                *(x+j) = *(x+i); /*上面的循环退出:即出现比基准点大的数,放到右边*/
                j--; /*前移一个位置*/
            }
        }
        *(x+i) = t; /*一遍扫描完后,放到适当位置*/
        quick_sort(x,low,i-1);   /*对基准点左边的数再执行快速排序*/
        quick_sort(x,i+1,high);   /*对基准点右边的数再执行快速排序*/
    }
}
/*
================================================
功能:堆排序
输入:数组名称(也就是数组首地址)、数组中元素个数
注：画画
================================================
*/
/*
功能:建堆
输入:数组名称(也就是数组首地址)、参与建堆元素的个数、从第几个元素开始
*/
void sift(int *x, int n, int s)
{
    int t, k, j;
    t = *(x+s); /*暂存开始元素*/
    k = s;   /*开始元素下标*/
    j = 2*k + 1; /*左子树元素下标*/
    while (j<n)
    {
        if (j<n-1 && *(x+j) < *(x+j+1))/*判断是否存在右孩子，并且右孩子比左孩子大，成立，就把j换为右孩子*/
        {
            j++;
        }
        if (t<*(x+j)) /*调整*/
        {
            *(x+k) = *(x+j);
            k = j; /*调整后,开始元素也随之调整*/
            j = 2*k + 1;
        }
        else /*没有需要调整了,已经是个堆了,退出循环。*/
        {
            break;
        }
    }
    *(x+k) = t; /*开始元素放到它正确位置*/
}
/*
功能:堆排序
输入:数组名称(也就是数组首地址)、数组中元素个数
注：
            *
         *     *
       *   -  *   *
      * * * 
建堆时，从从后往前第一个非叶子节点开始调整，也就是“-”符号的位置
*/
void heap_sort(int *x, int n)
{
    int i, k, t;
//int *p;
    for (i=n/2-1; i>=0; i--)
    {
        sift(x,n,i); /*初始建堆*/
    }
    for (k=n-1; k>=1; k--)
    {
        t = *(x+0); /*堆顶放到最后*/
        *(x+0) = *(x+k);
        *(x+k) = t;
        sift(x,k,0); /*剩下的数再建堆*/
    }
}
 
 
 
 
// 归并排序中的合并算法
void Merge(int a[], int start, int mid, int end)
{
    int i,k,j, temp1[10], temp2[10];
    int n1, n2;
    n1 = mid - start + 1;
    n2 = end - mid;
 
    // 拷贝前半部分数组
    for ( i = 0; i < n1; i++)
    {
        temp1[i] = a[start + i];
    }
    // 拷贝后半部分数组
    for (i = 0; i < n2; i++)
    {
        temp2[i] = a[mid + i + 1];
    }
    // 把后面的元素设置的很大
    temp1[n1] = temp2[n2] = 1000;
    // 合并temp1和temp2
    for ( k = start, i = 0, j = 0; k <= end; k++)
    {
        //小的放到有顺序的数组里
        if (temp1[i] <= temp2[j])
        {
            a[k] = temp1[i];
            i++;
        }
        else
        {
            a[k] = temp2[j];
            j++;
        }
    }
}
 
// 归并排序
void MergeSort(int a[], int start, int end)
{
    if (start < end)
    {
        int i;
        i = (end + start) / 2;
        // 对前半部分进行排序
        MergeSort(a, start, i);
        // 对后半部分进行排序
        MergeSort(a, i + 1, end);
        // 合并前后两部分
        Merge(a, start, i, end);
    }
}
/*顺序查找*/
void SequenceSearch(int *fp,int Length)
{
    int i;
    int data;
    printf("开始使用顺序查询.\n请输入你想要查找的数据.\n");
    scanf("%d",&data);
    for(i=0; i<Length; i++)
        if(fp[i]==data)
        {
            printf("经过%d次查找,查找到数据%d,表中位置为%d.\n",i+1,data,i);
            return ;
        }
    printf("经过%d次查找,未能查找到数据%d.\n",i,data);
}
/*二分查找*/
void Search(int *fp,int Length)
{
    int data;
    int bottom,top,middle;
    int i=0;
    printf("开始使用二分查询.\n请输入你想要查找的数据.\n");
    scanf("%d",&data);
    printf("由于二分查找法要求数据是有序的,现在开始为数组排序.\n");
    Sort(fp,Length);
    printf("数组现在已经是从小到大排列,下面将开始查找.\n");
    bottom=0;
    top=Length;
    while (bottom<=top)
    {
        middle=(bottom+top)/2;
        i++;
        if(fp[middle]<data)
        {
            bottom=middle+1;
        }
        else if(fp[middle]>data)
        {
            top=middle-1;
        }
        else
        {
            printf("经过%d次查找,查找到数据%d,在排序后的表中的位置为%d.\n",i,data,middle);
            return;
        }
    }
    printf("经过%d次查找,未能查找到数据%d.\n",i,data);
}
 
/*
下面测试了
*/
void Sort(int *fp,int Length)
{
    int temp;
    int i,j,k;
    printf("现在开始为数组排序,排列结果将是从小到大.\n");
    for(i=0; i<Length; i++)
        for(j=0; j<Length-i-1; j++)
            if(fp[j]>fp[j+1])
            {
                temp=fp[j];
                fp[j]=fp[j+1];
                fp[j+1]=temp;
            }
    printf("排序完成!\n下面输出排序后的数组:\n");
    for(k=0; k<Length; k++)
    {
        printf("%5d",fp[k]);
    }
    printf("\n");
 
}
/*构造随机输出函数类*/
void input(int a[])
{
    int i;
    srand( (unsigned int)time(NULL) );
    for (i = 0; i < 10; i++)
    {
        a[i] = rand() % 100;
    }
    printf("\n");
}
/*构造键盘输入函数类*/
/*void input(int *p)
{
     int i;
     printf("请输入 %d 个数据 :\n",MAX);
      for (i=0; i<MAX; i++)
      {
       scanf("%d",p++);
      }
      printf("\n");
}*/
/*构造输出函数类*/
void output(int *p)
{
    int i;
    for ( i=0; i<MAX; i++)
    {
        printf("%d ",*p++);
    }
}
void main()
{
    int start=0,end=3;
    int *p, i, a[MAX];
    int count=MAX;
    int arr[MAX];
    int choise=0;
    /*printf("请输入你的数据的个数:\n");
    scanf("%d",&count);*/
    /* printf("请输入%d个数据\n",count);
    for(i=0;i<count;i++)
    {
       scanf("%d",&arr[i]);
    }*/
    /*录入测试数据*/
    input(a);
    printf("随机初始数组为：\n");
    output(a);
    printf("\n");
    do
    {
        printf("1.使用顺序查询.\n2.使用二分查找法查找.\n3.退出\n");
        scanf("%d",&choise);
        if(choise==1)
            SequenceSearch(a,count);
        else if(choise==2)
            Search(a,count);
        else if(choise==3)
            break;
    }
    while (choise==1||choise==2||choise==3);
 
 
    /*录入测试数据*/
    input(a);
    printf("随机初始数组为：\n");
    output(a);
    printf("\n");
    /*测试选择排序*/
    p = a;
    printf("选择排序之后的数据:\n");
    select_sort(p,MAX);
    output(a);
    printf("\n");
    system("pause");
    /**/
    /*录入测试数据*/
    input(a);
    printf("随机初始数组为：\n");
    output(a);
    printf("\n");
    /*测试直接插入排序*/
    printf("直接插入排序之后的数据:\n");
    p = a;
    insert_sort(p,MAX);
    output(a);
    printf("\n");
    system("pause");
    /*录入测试数据*/
    input(a);
    printf("随机初始数组为：\n");
    output(a);
    printf("\n");
    /*测试冒泡排序*/
    printf("冒泡排序之后的数据:\n");
    p = a;
    insert_sort(p,MAX);
    output(a);
    printf("\n");
    system("pause");
    /*录入测试数据*/
    input(a);
    printf("随机初始数组为：\n");
    output(a);
    printf("\n");
    /*测试快速排序*/
    printf("快速排序之后的数据:\n");
    p = a;
    quick_sort(p,0,MAX-1);
    output(a);
    printf("\n");
    system("pause");
    /*录入测试数据*/
    input(a);
    printf("随机初始数组为：\n");
    output(a);
    printf("\n");
    /*测试堆排序*/
    printf("堆排序之后的数据:\n");
    p = a;
    heap_sort(p,MAX);
    output(a);
    printf("\n");
    system("pause");
    /*录入测试数据*/
    input(a);
    printf("随机初始数组为：\n");
    output(a);
    printf("\n");
    /*测试归并排序*/
    printf("归并排序之后的数据:\n");
    p = a;
    MergeSort(a,start,end);
    output(a);
    printf("\n");
    system("pause");
}

转载于https://fantianzuo.blog.csdn.net/article/details/115587600

Dragon Fly
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构_顺序查找(C语言)
小黯
07-18 1万+
从表的一端开始，依次将表中的关键字和给定的值进行比较，若表中的关键字和给定的值相等，则查找成功，反之查找失败。
排序与查找算法（C语言描述）
wangjun_huster的博客
04-10 942
排序算法选择排序
C语言实现查找（基于数据结构）
欢迎来到Gorit的博客
01-16 9782
1、问题提出 实现两种基本算法，顺序查找和折半查找   2、数据结构设计 typedef struct { KeyType key; //关键字域 }ElemType; typedef struct { ElemType data[LIST_SIZE]; //查找表存储空间 int length; //表长度 }SSTable;   3、函数类型说明 void ...
顺序查找（c语言实现）
m0_73372744的博客
04-22 1598
/将要查找的数赋给首元素。//把要查找的数作为数组的首元素，让数组从尾部开始查找，找到就结束数组。printf("该数在此列表的%d位", r);printf("该数不在此列表里");printf("请输入要查找的数：");printf("请输入元素个数：");printf("请输入元素：");
顺序查找的实现（C语言）
多多想的博客
10-23 361
顺序查找又称线性查找，对于顺序表和链表都适用。对于顺序表，可以通过数组下标递增来顺序扫描每个元素；对于链表，则通过指针next来依次扫描每个元素。下面练习中实现查找时，使用指针实现顺序表
C语言快速排序与二分查找算法示例
08-28
本文将详细介绍C语言快速排序与二分查找算法的实现技巧，并提供了一个完整的示例代码。 一、快速排序算法 快速排序算法是一种 Divide and Conquer 的算法，它的主要思想是选择一个关键数据，然后将数组分成两个...
C语言实现树的动态查找实例代码
01-01
C语言实现树的动态查找实例代码 本例演示一种树数据结构存储记录集合时的动态查找方法。首先程序通过construct()函数，利用已经存在的结构体数组数据建立一个二叉树，建立树的过程中，要保证每个节点的值都大于它的...
C语言的各种排序及查找的算法
12-06
在编程领域，C语言是一种广泛使用的底层编程语言，它的效率高、灵活性强，因此在实现各种算法时，C语言是首选之一。本话题主要聚焦于C语言中的排序和查找算法，这些是数据处理和问题解决的基础工具。接下来，我们将...
c语言实现快速排序（逐步优化）
08-01
c语言实现的快速排序算法，及其一步步优化代码（1. 数组长度较小时候选择插入排序；2. 主元在数组最左最右，中间三个数字中间选择中间大小的， 数组拆分后将 重复数字挪到主元附近，不进行重复partition）
C语言实现二叉排序树构造 查找删除节点 中序遍历
06-24
C语言实现二叉排序树构造 查找删除节点 中序遍历 已调试好
C语言查找排序算法源码大全
01-05
printf("\t*************选择排序实验报告****************\n"); printf("\t***********> 1.顺序查找 <*******\n"); printf("\t***********> 2.二分查找（非递归） <*******\n"); printf("\t***********> 3.二分查找（递归） <*******\n"); printf("\t***********> 4,直接插入排序 <*******\n"); printf("\t***********> 5.直接选择排序 <*******\n"); printf("\t***********> 6.起泡排序 <*******\n"); printf("\t***********> 7.快速排序 <*******\n"); printf("\t***********> 8.合并排序 <*******\n"); printf("\t***********> 9.结束程序 <*******\n"); printf("\t*********************************************\n");
​C语言顺序查找算法以及代码​
最新发布
sinat_41942180的博客
12-19 662
本节主要介绍了静态查找表的顺序存储的表示和查找算法的实现，其中使用监视哨对普通的顺序表的遍历算法做了改进，在数据量大的情况下，能够有效提高算法的运行效率。
查找（一）—— 顺序查找
qq_50685510的博客
08-27 3742
顺序查找（又称线性查找）是一种简单的查找算法，它按照数据元素的顺序从前往后依次查找目标元素。顺序查找的基本思路是将目标元素与当前位置的元素进行比较，若相等则查找成功；否则继续向后查找，直到找到目标元素或搜索到末尾位置为止。其中n为数据元素的个数。不论有序无序、连续存储还是离散存储，都能使用，使用范围广，但是速度慢，时间复杂度为O(n)。
C语言 数组的查找和排序方法 1.顺序查找 2.二分查找； 1.（简单）选择排序法 2.冒泡排序法 3.（直接）插入排序法
undefinedUser_1的博客
12-15 1万+
C语言 数组部分知识、实现数组查找和排序
C语言实现顺序查找
weixin_59566851的博客
12-02 8441
C语言顺序查找
用c语言实现顺序查找,顺序查找算法及C语言实现
weixin_32302013的博客
05-19 3483
通过前面对静态查找表的介绍，静态查找表即为只做查找操作的查找表。静态查找表既可以使用。虽然一个是本节以静态查找表的顺序存储结构为例做详细的介绍。顺序查找的实现静态查找表用顺序存储结构表示时，顺序查找的查找过程为：从表中的最后一个数据元素开始，逐个同记录的关键字做比较，如果匹配成功，则查找成功；反之，如果直到表中第一个关键字查找完也没有成功匹配，则查找失败。顺序查找的具体实现代码为：#include...
c语言实现排序和查找所有算法
hebtu666
07-31 7965
c语言版排序查找完成，带详细解释，一下看到爽，能直接运行看效果。 /* Note:Your choice is C IDE */ #include "stdio.h" #include"stdlib.h" #define MAX 10 void SequenceSearch(int *fp,int Length); void Search(int *fp,int length); vo...
折半查找（C语言）
热门推荐
子午的博客
05-25 2万+
折半查找： 设定查找范围的下限low，上限high， 由此确定查找范围的中间位置mid； 中间位置的值等于待查的值，查找成功 中间位置的值小于待查的值，low=mid+1 中间位置的值大于待查的值，high=mid-1 直到low>high，查找失败。 #include<stdio.h> #define NUM 10 int a[]={6,12,28,37,54,65,69...
请用c语言实现查找排序的各种算法操作
03-24
好的，以下是一些常见的查找和排序算法的 C 语言实现： 1. 线性查找算法： ```c int linearSearch(int arr[], int n, int x) { for (int i = 0; i ; i++) { if (arr[i] == x) { return i; } } return -1; } ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值