文件排序及二分查找法与冒泡排序法

char *fputs(char *s, int n, FILE *fp)
int fputs(char *s, FILE *fp)
fgets正常时返回读取字符串的首地址,出错或文件尾,返回NULL。
fputs正常时返回写入的最后一个字符,出错返回EOF。

#define  _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include <stdlib.h>
#include <time.h>

//文件排序

//内存排序

void main1()
{
    time_t ts;
    unsigned int num = time(&ts);//获取随机数种子
    srand(num);

    int a[100];
    for (int i = 0; i < 100;i++)
    {
        a[i] = rand() % 100;
    }
    FILE *pf = fopen("C:\\1.data", "wb");
    fwrite(a, sizeof(int), 100, pf);
    fclose(pf);

    system("pause");

}
int com(void *p1, void *p2)
{
    int *pint1 = p1;
    int *pint2 = p2;
    if (*pint1 >*pint2)
    {
        return 1; //大于
    }
    else if (*pint1 <*pint2)
    {
        return -1;//小于
    }
    else
    {
        return 0;
    }
    //>  1,0

}
//读取到内存,然后排序
void memsort()
{
    int *p = malloc(400);
    int *pread = malloc(400);
    FILE *pf = fopen("C:\\1.data", "rb+");
    fread(p, sizeof(int), 100, pf);
    for (int i = 0; i < 100; i++)
    {
        printf("\n%d", p[i]);
    }
    fflush(pf);//刷新,生效

    qsort(p, 100, 4, com);//排序
    printf("sort later\n");
    for (int i = 0; i < 100; i++)
    {
        printf("\n%d", p[i]);
    }
    rewind(pf);
    fwrite(p, sizeof(int), 100, pf);
    fflush(pf);//刷新,生效
    rewind(pf);
    fread(pread, sizeof(int), 100, pf);
    fflush(pf);//刷新,生效
    for (int i = 0; i < 100;i++)
    {
        printf("\npread=%d", pread[i]);
    }

    fclose(pf);

}

void fileread()
{
    FILE *pf = fopen("C:\\1.data", "rb");
    for (int i = 0; i < 100;i++)
    {
        int num;
        fseek(pf,i*sizeof(int) , SEEK_SET);//i顺序,99-i逆序
        fread(&num, sizeof(int), 1, pf);
        if (num==3)
        {
            printf("%d", num);//顺序查找 100
        } 

        printf("\nnum=%d", num);
    }
    fclose(pf);

}

void binsearch(int findnum)
{
    FILE *pf = fopen("C:\\1.data", "rb");
    int tou = 0;
    int wei = 99;
    int flag = 0;
    int ci = 0;
    while (tou<=wei)
    {
        ci++;
        int  zhong = (tou + wei) / 2;
        //a[zhong]
        int  zhongdata;
        fseek(pf,zhong*sizeof(int), SEEK_SET);//i顺序,99-i逆序
        fread(&zhongdata, sizeof(int), 1, pf);
        if (findnum==zhongdata)
        {
            flag = 1;//找到
            printf("\n找到%d", zhongdata);
            break;
        }
        else if (findnum > zhongdata)
        {
            tou = zhong + 1;
        }
        else
        {
            wei = zhong - 1;
        }

    }
    if (flag)
    {
        printf("找到了\n");
    }
    else
    {
        printf("没找到了\n");
    }
    printf("找了%d次",ci);

    fclose(pf);

}
void main3x()
{
    //memsort();
    //fileread();
    fileread();
    while (1)
    {
        int findnum;
        scanf("%d", &findnum);
        binsearch(findnum);
    }
    system("pause");

}

void randwirte()
{
    time_t ts;
    unsigned int num = time(&ts);//获取随机数种子
    srand(num);

    int a[100];
    for (int i = 0; i < 100; i++)
    {
        a[i] = rand() % 100;
    }
    FILE *pf = fopen("C:\\sort.data", "wb");
    fwrite(a, sizeof(int), 100, pf);
    fclose(pf);

}
void showfile()
{
    int *p = malloc(400);
    FILE *pf = fopen("C:\\sort.data", "rb");
    fread(p, sizeof(int), 100, pf);
    for (int i = 0; i < 100; i++)
    {
        printf("\n%d", p[i]);
    }
    fclose(pf);

}

void main()
{
    //showfile();
    showfile();
    printf("\n排序以后");
    FILE *pf = fopen("C:\\sort.data", "rb+");
    for (int i = 0; i < 100 - 1;i++)
    {
        for (int j = 0; j < 100 - 1 - i;j++)
        {
            int dataj = 0;
            fseek(pf, sizeof(int)*j, SEEK_SET);
            fread(&dataj, sizeof(int), 1, pf);

            int dataj1 = 0;
            fseek(pf, sizeof(int)*(j+1), SEEK_SET);
            fread(&dataj1, sizeof(int), 1, pf);
            if (dataj <dataj1)
            {
                fseek(pf, sizeof(int)*(j + 1), SEEK_SET);
                fwrite(&dataj, 4, 1, pf);

                fseek(pf, sizeof(int)*j, SEEK_SET);
                fwrite(&dataj1, 4, 1, pf);
            }

            /*if (a[j]<a[j+1])
            {
                swap(a[j] a[j+1])
            }*/
        }
    }
    fclose(pf);
    showfile();
    system("pause");
}
时间: 2024-11-05 18:51:15

文件排序及二分查找法与冒泡排序法的相关文章

hdu 4938 Seeing People 排序+二分查找

Seeing People Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 241    Accepted Submission(s): 61 Problem Description There are two kinds of people. If person i is the first kind of people, it

数组冒泡排序、选择排序、二分查找法

1 数组高级冒泡排序原理图解[掌握] 画图演示 需求: 数组元素:{24, 69, 80, 57, 13} 请对数组元素进行排序. 冒泡排序 相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处 2 数组高级冒泡排序代码实现[掌握] 案例演示 数组高级冒泡排序代码 package com.heima.array; public class Demo1_Array { public static void main(String[] args) { int[] arr = {24,

java——类型转换,冒泡排序,选择排序,二分查找,数组的翻转

一.类型转换 p { margin-bottom: 0.25cm; direction: ltr; color: #000000; line-height: 120%; text-align: justify; widows: 0; orphans: 0 } p.western { font-family: "Calibri", sans-serif; font-size: 10pt } p.cjk { font-family: "宋体"; font-size: 1

八大排序算法二分查找

import java.util.ArrayList;import java.util.Arrays;import java.util.List; import org.junit.Test; public class InsertSort { public static void display(int[] arr){ System.out.print("["); for(int i=0;i<arr.length;i++){ if(i == arr.length-1){ Sys

StringBuffer、StringBuilder、冒泡与选择排序、二分查找、基本数据类型包装类_DAY13

1:数组的高级操作(预习) (1)数组:存储同一种数据类型的多个元素的容器. (2)特点:每个元素都有从0开始的编号,方便我们获取.专业名称:索引. (3)数组操作: A:遍历 public static void printArray(int[] arr) { for(int x=0; x<arr.length; x++) { System.out.println(arr[x]); } } B:获取最值 public static int getMax(int[] arr) { int max

Java基础【冒泡、选择排序、二分查找】

冒泡排序的思路就是前一个和后一个进行比较,如果大的就交换位置   大的数字后浮 如   12      8    5     31 第一轮   8   5   12   31 第二轮   5   8    12   31 ........ 代码如下 package com.zuoyan.sort; /** * 冒泡排序 * @author Administrator * */ public class BubbloSortDemo { public static void main(String

基础排序、二分查找汇总

一.常见排序算法复杂度和稳定性 二.js代码实现和思路 (1)冒泡排序:从数组起始位置两两比较,前一个大于后一个就交换位置,第一轮比较后最大的那个数就排到了最后,循环比较数组长度-1次 function bubble (arr) { for (let j = 0; j < arr.length - 1; j++) { for (let i = 0; i < arr.length - 1 - j; i++) { if (arr[i] > arr[i + 1]) { [arr[i], arr

选择排序法、冒泡排序法

选择排序法 int main(int argc, char *argv[]) { int i, j, iMin; int tmp; int nNums[10] = {2,123,541,32,12,74,92,50,8,21}; for(i=0;i<10-1;i++) { iMin = i;    //提取数据的每个位置 for(j=i+1;j<10;j++)  //每次循环,通过iMin获取最小值的下标. { if(nNums[iMin]>nNums[j])   //判断是否最小,比i

[LeetCode] 33. 搜索旋转排序数组 ☆☆☆(二分查找)

描述 假设按照升序排序的数组在预先未知的某个点上进行了旋转. ( 例如,数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] ). 搜索一个给定的目标值,如果数组中存在这个目标值,则返回它的索引,否则返回 -1 . 你可以假设数组中不存在重复的元素. 你的算法时间复杂度必须是 O(log n) 级别. 示例 1: 输入: nums = [4,5,6,7,0,1,2], target = 0输出: 4示例 2: 输入: nums = [4,5,6,7,0,1,2], ta