建立顺序表，然后使用顺序查找来查找指定值，然后建立有序表，使用折半查询来查找指定值（使用c语言）

在C语言中，建立顺序表（数组）和使用顺序查找的基本步骤如下：

1. **创建顺序表（数组）**：

#include <stdio.h>

typedef struct {
    int data;       // 数据元素类型
    int size;
    int capacity;   // 容量大小
} SequenceList;

// 初始化函数
void initialize(SequenceList* list) {
    list->data = (int*)malloc(list->capacity * sizeof(int));
    list->size = 0;
}

// 插入元素
void insert(SequenceList* list, int value) {
    if (list->size == list->capacity) {
        list->capacity *= 2;
        list->data = (int*)realloc(list->data, list->capacity * sizeof(int)); // 动态扩容
    }
    list->data[list->size++] = value;
}

2. **顺序查找**：

int search(SequenceList* list, int target) {
    for (int i = 0; i < list->size; i++) {
        if (list->data[i] == target) {
            return i;     // 找到目标值，返回其索引
        }
    }
    return -1;         // 如果没找到，返回-1表示未找到
}

int main() {
    SequenceList my_list;
    initialize(&my_list);
    // 插入元素并查找...
}

对于有序表，例如二分查找（折半查询），我们需要维护列表的有序性，并改变插入元素的方式。这里展示基本思路：

1. **创建有序顺序表（动态数组）**：

// 为了保持有序，我们可以使用双向链表作为底层结构，方便插入和查找
typedef struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
} Node;

// 插入有序
void insert_sorted(Node** head, int value) {
    Node* newNode = malloc(sizeof(Node));
    newNode->data = value;
    newNode->prev = NULL;
    newNode->next = *head;

    if (*head != NULL && value < (*head)->data) {
        newNode->next->prev = newNode;
    } else {
        while (newNode->next != NULL && newNode->data > newNode->next->data) {
            newNode = newNode->next;
        }
        if (newNode->next != NULL) {
            newNode->next->prev = newNode;
        } else {
            *head = newNode;
        }
    }
}

2. **折半查找**：

int binary_search(Node* head, int target) {
    int low = 0, high = -1;  // 初始化边界

    if (head != NULL) {
        high = head->size - 1;
    }

    while (low <= high) {
        int mid = (low + high) / 2;
        if (head[mid].data == target) {
            return mid;  // 找到目标值
        } else if (head[mid].data < target) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }

    return -1;  // 没有找到
}

**相关问题--**:
1. 为什么在有序列表上使用二分查找比顺序查找效率高？
2. 如何保证插入新元素后的列表仍然有序？
3. 序列查找和二分查找的时间复杂度分别是多少？