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

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

---

动态顺序表

一、动态顺序表定义

#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