C语言实现动态顺序表(列表)操作及折半查找算法

最新推荐文章于 2024-07-25 20:45:37 发布
最新推荐文章于 2024-07-25 20:45:37 发布
阅读量2.3k 收藏 25
点赞数 1
分类专栏： 数据结构 文章标签： C语言 动态顺序表 动态列表 折半查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41870552/article/details/108541817
版权

动态顺序表及折半查找的实现

文章目录

动态顺序表

一、动态顺序表定义

#define InitSize 15

//动态分配顺序表定义
typedef struct {
    int *data;
    int MaxSize;
    int TableLen;//表的长度
} SqList;

二、动态顺序表初始化

//初始化动态顺序表
void InitList(SqList &L) {
    //用malloc函数申请一个存储空间，0号位
    L.data = (int *) malloc(InitSize * sizeof(int));
    L.TableLen = 0;
    L.MaxSize = InitSize;
}

三、动态顺序表相关操作

1.增加动态数组长度

//增加动态数组长度
void IncreaseSize(SqList &L, int len) {
    int *p = L.data;
    //重新申请符合长度的连续空间
    L.data = (int *) malloc((L.MaxSize + len) * sizeof(int));
    //将原空间里的数据复制到新的区域
    for (int i = 0; i < L.TableLen; ++i) {
        L.data[i] = p[i];
    }
    //顺序表的最大长度增加 len
    L.MaxSize += len;
    //释放原来的顺序表所占的空间
    free(p);
}

2.动态顺序表顺序插入元素

//动态顺序表插入
bool ListInsert(SqList &L, int i, int e) {
    if (i < 1 || i > L.TableLen + 1)//判断插入的位置是否不符合
        return false;
    else if (L.TableLen >= L.MaxSize)//判断顺序表是否已满
        return false;
    else {
        //将要插入的位置及后面的位置上的元素依次往后移动一位
        for (int D = L.TableLen; D >= i; --D) {
            L.data[D] = L.data[D - 1];
        }
        //在要插入的位置上插入值
        L.data[i - 1] = e;
        //顺序表的长度加1
        L.TableLen++;
        return true;
    }
}

3.动态顺序表删除

//动态顺序表删除
bool ListDelete(SqList &L, int i, int &e) {
    //判断位置i是否有效
    if (i < 1 || i > L.TableLen)
        return false;
    //将被删除的元素赋值给e
    e = L.data[i - 1];
    //将第i个位置后的元素依次向前移动1位
    for (int D = i; D < L.TableLen; ++D) {
        L.data[D - 1] = L.data[D];
    }
    //表的长度减1
    L.TableLen--;
    retur

4.动态顺序表按位查找

//动态顺序表按位查找，获取顺序表中的第i个位置的元素值
bool GetElem(SqList L, int i, int &e) {
    if (i < 1 || i > L.TableLen) {
        return false;
    } else {
        e = L.data[i - 1];
        return true;
    }
}

5.动态顺序表按值查找

//按值查找，查找给定的某个值在顺序表中的位置
bool LocalElem(SqList L, int v, int &index) {
    for (int i = 0; i < L.TableLen; ++i) {
        if (L.data[i] == v) {
            index = i + 1;
            return true;
        }
    }
    return false;
}

折半查找实现算法

一、基于升序顺序表的查找

//折半查找（升序表）
int Binary_Search_Up(SqList D, int key) {
    int low = 0, high = D.TableLen - 1, mid;
    while (low <= high) {
        mid = (low + high) / 2;
        if (D.data[mid] == key)
            return mid;
        else if (D.data[mid] > key)
            high = mid - 1;
        else
            low = mid + 1;
    }
    return -1;
}

二、基于降序顺序表的查找

//折半查找（降序表）
int Binary_Search_Down(SqList D, int key) {
    int low = 0, high = D.TableLen - 1, mid;
    while (low <= high) {
        mid = (low + high) / 2;
        if (D.data[mid] == key)
            return mid;
        else if (D.data[mid] > key)
            low = mid + 1;
        else
            high = mid - 1;
    }
    return -1;
}

项目完整代码

//动态顺序数组实现折半查找实现
#include<stdio.h>
#include<stdlib.h>

#define InitSize 15

//动态分配顺序表定义
typedef struct {
    int *data;
    int MaxSize;
    int TableLen;//表的长度
} SqList;

//初始化动态顺序表
void InitList(SqList &L) {
    //用malloc函数申请一个存储空间，0号位
    L.data = (int *) malloc(InitSize * sizeof(int));
    L.TableLen = 0;
    L.MaxSize = InitSize;
}

//增加动态数组长度
void IncreaseSize(SqList &L, int len) {
    int *p = L.data;
    //重新申请符合长度的连续空间
    L.data = (int *) malloc((L.MaxSize + len) * sizeof(int));
    //将原空间里的数据复制到新的区域
    for (int i = 0; i < L.TableLen; ++i) {
        L.data[i] = p[i];
    }
    //顺序表的最大长度增加 len
    L.MaxSize += len;
    //释放原来的顺序表所占的空间
    free(p);
}

//动态顺序表插入
bool ListInsert(SqList &L, int i, int e) {
    if (i < 1 || i > L.TableLen + 1)//判断插入的位置是否不符合
        return false;
    else if (L.TableLen >= L.MaxSize)//判断顺序表是否已满
        return false;
    else {
        //将要插入的位置及后面的位置上的元素依次往后移动一位
        for (int D = L.TableLen; D >= i; --D) {
            L.data[D] = L.data[D - 1];
        }
        //在要插入的位置上插入值
        L.data[i - 1] = e;
        //顺序表的长度加1
        L.TableLen++;
        return true;
    }
}

//动态顺序表删除
bool ListDelete(SqList &L, int i, int &e) {
    //判断位置i是否有效
    if (i < 1 || i > L.TableLen)
        return false;
    //将被删除的元素赋值给e
    e = L.data[i - 1];
    //将第i个位置后的元素依次向前移动1位
    for (int D = i; D < L.TableLen; ++D) {
        L.data[D - 1] = L.data[D];
    }
    //表的长度减1
    L.TableLen--;
    return true;
}

//动态顺序表按位查找，获取顺序表中的第i个位置的元素值
bool GetElem(SqList L, int i, int &e) {
    if (i < 1 || i > L.TableLen) {
        return false;
    } else {
        e = L.data[i - 1];
        return true;
    }
}

//按值查找，查找给定的某个值在顺序表中的位置
bool LocalElem(SqList L, int v, int &index) {
    for (int i = 0; i < L.TableLen; ++i) {
        if (L.data[i] == v) {
            index = i + 1;
            return true;
        }
    }
    return false;
}

//折半查找（升序表）
int Binary_Search_Up(SqList D, int key) {
    int low = 0, high = D.TableLen - 1, mid;
    while (low <= high) {
        mid = (low + high) / 2;
        if (D.data[mid] == key)
            return mid;
        else if (D.data[mid] > key)
            high = mid - 1;
        else
            low = mid + 1;
    }
    return -1;
}

//折半查找（降序表）
int Binary_Search_Down(SqList D, int key) {
    int low = 0, high = D.TableLen - 1, mid;
    while (low <= high) {
        mid = (low + high) / 2;
        if (D.data[mid] == key)
            return mid;
        else if (D.data[mid] > key)
            low = mid + 1;
        else
            high = mid - 1;
    }
    return -1;
}

int main() {
    //声明升序和降序动态顺序表
    SqList D_u;
    SqList D_d;

    //初始化升序和降序动态顺序表
    InitList(D_u);
    InitList(D_d);

    int arr[] = {7, 10, 13, 16, 19, 29, 32, 33, 37, 41, 43};
    int arr_len = sizeof(arr) / sizeof(int);

    //将元素逐个插入数组
    for (int i = 1; i <= arr_len; ++i) {
        ListInsert(D_u, i, arr[i - 1]);         //升序数组逐个插入
        ListInsert(D_d, i, arr[arr_len - i]);   //降序数组逐个插入
    }

    int result, key;
    key = 43;
    //升序顺序表的折半查找
    result = Binary_Search_Up(D_u, key);
    if (result == -1)
        printf("在升序表中查找失败！\n");
    else
        printf("在升序表中查找成功，%d在数组中的下标为：%d\n", key, result);

    //降序顺序表的折半查找
    result = Binary_Search_Down(D_d, key);
    if (result == -1)
        printf("在降序表中查找失败！\n");
    else
        printf("在降序表中查找成功，%d在数组中的下标为：%d\n", key, result);
    return 0;
}

运行效果图

int arr[] = {7, 10, 13, 16, 19, 29, 32, 33, 37, 41, 43};

1.查找元素43
在这里插入图片描述
2.查找元素26
在这里插入图片描述

Geekingdom
关注
专栏目录
c语言实现顺序查找、折半查找和散列表的查找功能
weixin_64055968的博客
03-08 259
实现顺序查找、折半查找和散列表的查找功能。
数据结构 c语言版 有序表的折半查找 算法,数据结构C语言版_折半查找
weixin_42252435的博客
05-24 1142
数据结构C语言版_折半查找/*数据结构C语言版 折半查找P219编译环境：Dev-C++ 4.9.9.2日期：2011年2月15日*/#include #include #define N 11 // 数据元素个数typedef int KeyType; // 设关键字域为整型typedef struct // 数据元素类型{KeyType key;// 关键字域int others;// 其它部...
顺序表的折半查找（Ｃ语言）
12-16
折半查找的Ｃ语言程序，可用 基于Ｃ语言的程序 利用顺序表，学习数据结构时会有用
顺序表-折半查找
qq_61706112的博客
09-09 1055
/*线性表(a1,a2,a3,...,an)中的元素递增有序且按顺序存储于计算机内。要求设计一个算法，完成 用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置相交换，若找不到，则将 其插入表中并使表中元素仍递增有序*/ #include<stdio.h> #include<stdlib.h> #define InitSize 10 typedef int ElemType; typedef struct{ ElemType *data; int length; }.
C 语言动态顺序表
最新发布
qq_68495605的博客
07-25 729
【代码】C 语言动态顺序表。
【数据结构C语言】顺序表的查找——折半查找
江~~~
05-17 2780
#include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 typedef struct { char name; int key; }ElemType; typedef struct { ElemType *R; int length; }SSTable; int Init(SSTabl...
【c练习】二分查找(折半查找)
qq_43676757的博客
03-11 684
二分查找(折半查找) 定义：二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。在C语言顺序存储结构中可更加快捷，时间复杂度更小的查找方式。 算法要求： 1.必须采用顺序存储结构。 2.必须按关键字大小有序排列。 查找过程 首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果...
顺序表折半查找
weixin_47919250的博客
09-03 2951
Description 创建一个一维数组，指定该一维数组的大小n，输入数组的n个元素，首先按指定算法(直接插入)对数组排序，输出排序结果，然后在排序的基础上，输入要查找的数值X，利用“折半法”查找其关键字等于X 的数据元素，若找到，则输出该元素在排序后表中的位置(1...n)，否则为0，并输出查找次数。 Input 第一行：输入一个整数n表示数组的长度（1<n<1000） 第二行：输入n个整数，整数之间用空格分隔 第三行：输入一个整数X为要查找的数值 Output 第一行：输出n个排序后..
C语言实现顺序表的顺序查找和折半查找
08-25
C语言实现顺序表的顺序查找和折半查找 在计算机科学中，查找是指在一组数据中找到特定元素的过程。顺序表是一种基本的数据结构，在实际应用中非常常见。因此，学习如何在顺序表中实现查找是非常重要的。下面，我们...
用c语言实现顺序表的顺序和折半查找
05-13
以下是用c语言实现顺序表的顺序查找和折半查找的示例代码： ```c #include #define MAX_SIZE 100 typedef struct { int data[MAX_SIZE]; int length; } SeqList; // 初始化顺序表 void initList(SeqList* ...
＜数据结构＞折半查找算法实现
weixin_46364330的博客
10-31 8251
文章目录前言一、折半查找算法（采用顺序表存储结构）二、使用步骤1.代码功能实现总结 前言 提示：本篇主要是本小白大学期间对数据结构实验的一些基本代码功能实现，希望对一同数据结构的伙伴有所帮助。 提示：以下是本篇文章正文内容，下面案例可供参考 一、折半查找算法（采用顺序表存储结构） 要求：编写函数，建立有序表，采用折半查找实现某一已知的关键字的查找。（采用顺序表存储结构） 折半算法思想：设置两个指针low，high，分为上界和下界，对于初始low=0 high=n-1; 令mid=（low+high）/2
C语言实现折半查找算法
05-05
用C语言实现折半查找，折半查找算法较简单
C语言程序设计实现二分查找算法
04-13
.1设计内容 《二分查找算法》 1)将二分查找元素算法分为三个部分输入元素、查找元素、进行判断! 2)如果查找的元素在原始的元素中找不到话可以进行判定是否进行重新输入，查找，可以选择拒绝1 3)输入原始元素使用升序输入，采用切割的方法进行查找，不停的切割，进行查找，知道找到和查找元素，输出下标
数据结构折半查找算法（C语言版）
10-10
折半查找算法 顺序表 折半查找算法C语言版
顺序表查找和折半查找
非专业业余程序员
01-16 555
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;malloc.h&gt; #include &lt;memory.h&gt; //包含memsetd的函数 //对两个数值型关键字的比较约定如下： #define EQ(a,b) ((a) == (b)) #define LT(a,b) ((a) &lt; (...
数组与链表
爱无止
11-21 210
前言小说网站 wap.youxs.org 数组和链表是两种数据结构,数组非常简单易用但是它有两个非常大的缺点,一个是数组一旦创建无法扩展,另一个则是数组的查找和删除的速度很慢. 链表改善了一些数组的缺点,但是同样的链表自身也存在一些自己的缺点. 本篇博客将为大家介绍一下这数组和链表特点及各自的优缺点. 阅读前的准备工作 大O表示法,一种粗略的评价计算机算法效率的方法.后面的内容会用到表示...
顺序查找和折半查找
aiduier5316的博客
07-22 260
1. 顺序查找 指从列表头开始顺序搜索列表。 如果项目并非以某种顺序排列，就只能使用顺序查找。如果要搜索的项目不在列表里，就得搜索完所有的项目才能得出该项目在不在列表里面。 int seq(int *array, int low, int high, int key) { for(int i = low; i < high; i++) { if(ar...
Day_41顺序查找与折半查找
DARRENANJIAN的博客
06-04 1133
顺序查找和折半查找
算法与数据结构(九) 查找表的顺序查找、折半查找、插值查找以及Fibonacci查找(Swift版)...
weixin_33694620的博客
11-15 142
今天这篇博客就聊聊几种常见的查找算法，当然本篇博客只是涉及了部分查找算法，接下来的几篇博客中都将会介绍关于查找的相关内容。本篇博客主要介绍查找表的顺序查找、折半查找、插值查找以及Fibonacci查找。本篇博客会给出相应查找算法的示意图以及相关代码，并且给出相应的测试用例。当然本篇博客依然会使用面向对象语言Swift来实现相应的Demo，并且会在github上进行相关Demo的分享。 查找在生活中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值