1、顺序表

合集 - 数据结构-c语言实现(14)

1.2、链表2024-09-13

2.1、顺序表2024-09-09

3.3、静态链表2024-09-134.4、循环单链表2024-09-145.6、栈2024-09-166.5、循环双链表2024-09-167.7、队列2024-09-168.8、串的顺序存储2024-09-279.9、串的堆分配方式2024-09-2710.10、广义表2024-09-2711.11、稀疏矩阵的压缩存储2024-09-2712.12、二叉树2024-09-2913.13、线索二叉树2024-09-2914.14、图-邻接矩阵2024-09-29

收起

#include<stdio.h>
#include<malloc.h>
#include<stdbool.h>
#define SEQLIST_INIT_SIZE 8
typedef int ElemType;
//结构体定义 
typedef struct SeqList{
    ElemType* base;
    int size;
    int capacity;  
}SeqList;
    
//初始化结构体 
void initSeqList(SeqList* seqList){
    seqList->base = (ElemType*)malloc(sizeof(SeqList) * SEQLIST_INIT_SIZE); //申请内存空间 
    seqList->size = 0;//初始顺序表当前大小为0 
    seqList->capacity = SEQLIST_INIT_SIZE;//顺序表容量为  SEQLIST_INIT_SIZE
}
////尾插法
//void push_back(SeqList* seqList,ElemType e){
//    //判断容量是否已满 
//    if(seqList->size >= seqList->capacity){
//        printf("当前顺序表容量已满,不能向尾部插入数据>%d. \n",e);
//        return;
//    }
//    //插入数据到尾部 
//    seqList->base[seqList->size] = e;
//    //数组当前容量大小 + 1 
//    seqList->size++;
//}

//头插法
void push_front(SeqList* seqList,ElemType e){
    //判断容量是否已满 
    if(seqList->size >= seqList->capacity){
        printf("当前顺序表容量已满,不能向头部插入数据>%d. \n",e);
        return;
    }
    int i = 0;
    //将数组当前所有元素后移 
    for(i = seqList->size; i > 0; i--){
        seqList->base[i] = seqList->base[i-1];
    }
    //插入数据到头部 
    seqList->base[0] = e;
    //数组当前容量大小 + 1 
    seqList->size++;
}

//显示数据中的所有数据
void show_list(SeqList seqList){
    int i = 0;
    for(i = 0;i < seqList.size;i++){
        printf("%d ",seqList.base[i]);
    }
    printf("\n");
}

//删除尾部
void pop_back(SeqList* seqList){
    //判断当前数组是否为空
    if(seqList->size == 0){
        printf("当前数组为空，不能进行删除尾部.\n");
        return;
    } 
    //只需更改size大小即可 
    seqList->size--;
}

//删除头部
void pop_front(SeqList* seqList){
    //判断当前数组是否为空
    if(seqList->size == 0){
        printf("当前数组为空，不能进行删除头部.\n");
        return;
    } 
    int i = 1;
    //数组数据前移 
    for(i = 1;i < seqList->size;i++){
        seqList->base[i-1] = seqList->base[i];
    }
    //数组当前大小-1 
    seqList->size--;
}

//向顺序表的 position 位置插入 e 元素
//注：这里位置为数据下标 
void insert_pos(SeqList* seqList,int position,ElemType e){
    //判断 插入的位置[position] 是否合法 
    if(position < 0 || position > seqList->size){
        printf("插入的位置[position]不合法，不能插入数据.\n");
        return;
    }
    //判断当前数组是否已满
    if(seqList->size >= seqList->capacity){
        printf("当前数组已满，不能插入数据.\n");
        return;
    }
    
    //    if(position == 0){
    //        //如果插入的位置为第一个元素，则调用头插法函数 
    //        push_front(seqList,e);
    //    }else if(position == seqList->size){
    //        //如果插入的位置为最后一个元素，则调用头插法函数 
    //        push_back(seqList,e);
    //    }else{
    //        //如果既不是头部也不是尾部，
    //        //在中间插入元素
    //        int i = seqList->size;
    //        for(i;i > position;i--){
    //            seqList->base[i] = seqList->base[i - 1];
    //        }
    //        seqList->base[position] = e;
    //        seqList->size++;
    //    }
    int i = seqList->size;
    for(i;i > position;i--){
        seqList->base[i] = seqList->base[i - 1];
    }
    seqList->base[position] = e;
    seqList->size++;
}

//查找顺序表元素 
int find(SeqList seqList,ElemType e){
    int i = 0;
    for(i;i < seqList.size;i++){
        if(seqList.base[i] == e){
            return i;
        }
    }
    return -1;
}

//顺序表长度
int length(SeqList seqList){
    return seqList.size;
}
 
//删除顺序表的 pos 位置的元素
//注: pos代表元素下标位置 
void delete_pos(SeqList* seqList,int pos){
    if(pos < 0 || pos >= seqList->size){
        printf("删除的数据位置不合法，不能删除数据.\n");
        return;
    }
    int i = pos;
    for(i;i< seqList->size - 1;i++){
        seqList->base[i] = seqList->base[i+1];
    }
    seqList->size--;
}

//按值删除元素
void delete_val(SeqList* seqList,ElemType e){
    int pos = find(*seqList,e);
    if(pos == -1){
        printf("按值删除失败,当前val: %d 不存在顺序表中.\n",e);
        return;
    }
    delete_pos(seqList,pos);
} 



//排序(从小到大) 
void sort(SeqList* seqList){
    int i = 0;
    int size = seqList->size;
    for(i;i < size - 1;i++){
        int flag = 0;//判断这次循环是否有把元素前移
        int j = 0; 
        for(j;j < size - i;j++){
            if(seqList->base[j] > seqList->base[j + 1]){
                ElemType temp = seqList->base[j];
                seqList->base[j] = seqList->base[j + 1];
                seqList->base[j + 1] = temp;
                flag = 1;//当前有变换 
            }
        }
        if(flag == 0){
            //说明当前已经排序好了 
            return;
        }
        
    }
} 

//逆置顺序表
void reverse(SeqList* seqList){
    int low = 0;
    int high = seqList->size - 1;
    while(low < high){
        ElemType temp = seqList->base[low];
        seqList->base[low] = seqList->base[high];
        seqList->base[high] = temp;
        low++;
        high--;
    }
} 

//清空顺序表
void clear(SeqList* seqList){
    seqList->size = 0;
}

//销毁顺序表
void  destory(SeqList* seqList){
    free(seqList->base);//释放所指的空间
    seqList->base = NULL;
    seqList->size = 0;
    seqList->capacity = 0;
}

#define INC_SIZE 8
//扩容
bool capacity_inc(SeqList* seqList){
    ElemType* newBase = (ElemType*)realloc(seqList->base,sizeof(ElemType) * (seqList->capacity + INC_SIZE));
    if(newBase == NULL){
        printf("增配空间失败，内存不足.\n");    
        return false;
    }
    seqList->base = newBase;
    seqList->capacity += INC_SIZE;
    return true;
} 

//尾插法[扩容改进]
void push_back(SeqList* seqList,ElemType e){
    //判断容量是否已满 且 是否可以进行扩容 
    if(seqList->size >= seqList->capacity && !capacity_inc(seqList)){
        printf("当前顺序表容量已满,不能向尾部插入数据>%d. \n",e);
        return;
    }
    //插入数据到尾部 
    seqList->base[seqList->size] = e;
    //数组当前容量大小 + 1 
    seqList->size++;
}

//数组合并[从小到大]
void merge(SeqList* list,SeqList* list_a,SeqList* list_b){
    list->capacity = list_a->size + list_b->size;

    list->base = (SeqList*) malloc(sizeof(ElemType) * list->capacity);
    if(list->base == NULL){
        printf("内存空间不足.\n");
        return;
    }
    int index_a = 0;
    int index_b = 0;
    int index = 0;
    while(index_a < list_a->size && index_b < list_b->size){
        if(list_a->base[index_a] < list_b->base[index_b]){
            list->base[index] = list_a->base[index_a];
            index_a++;
            index++;
            //list->base[index++] = list_a->base[index_a++];
        }else{
            list->base[index] = list_b->base[index_b];
            index_b++;
            index++;
            //list->base[index++] = list_b->base[index_b++];
        }
    }
    while(index_a < list_a->size){
        list->base[index++] = list_a->base[index_a++];
    }
    while(index_b < list_b->size){
        list->base[index++] = list_b->base[index_b++];
    }
    list->size = list_a->size + list_b->size;
} 
int main(){
    SeqList myList;
    initSeqList(&myList);
    int select = 1;
    while(select){
        printf("***********************************\n");
        printf("* [1] push_back   [2] push_front  *\n");
        printf("* [3] show_list   [4] pop_back    *\n");
        printf("* [5] pop_front   [6] insert_pos  *\n");
        printf("* [7] find        [8] length      *\n");
        printf("* [9] delete_pos  [10] delete_val *\n");
        printf("* [11] sort       [12] reverse    *\n");
        printf("* [13] clear      [14] destory    *\n");
        printf("* [0] quit_system                 *\n");
        printf("***********************************\n");
        printf("请选择:>");
        scanf("%d",&select);
        if(select == 0){
            break;
        }
        int item = 0;
        int pos = 0;
        switch(select){
            case 1:    
                printf("请输入要输入的数据(-1结束):>");
                while(scanf("%d",&item),item != -1){
                    push_back(&myList,item);
                }
                break;
            case 2:
                printf("请输入要输入的数据(-1结束):>");
                while(scanf("%d",&item),item != -1){
                    push_front(&myList,item);
                }
                break;
            case 3:
                show_list(myList);
                break;
            case 4:
                pop_back(&myList);
                break;
            case 5:
                pop_front(&myList);
                break;
            case 6:
                printf("请输入要插入的位置:>",pos);
                scanf("%d",&pos);
                printf("请输入要输入的数据:>",item);
                scanf("%d",&item);
                insert_pos(&myList,pos,item);
                break;
            case 7:
                printf("请输入要查找的数据:>");
                scanf("%d",&item);
                pos = find(myList,item);
                if(pos == -1){
                    printf("查找到数据 %d 在顺序表中不存在.\n",item);
                }else{
                    printf("找到数据 %d 在顺序表中的 %d 的位置.n",item,pos);
                }
                break;
            case 8:
                printf("该顺序表长度为 %d.\n",length(myList));
                break;
            case 9:
                printf("请输入要删除的位置:>");
                scanf("%d",&pos);
                delete_pos(&myList,pos);
                break; 
            case 10:
                printf("请输入要删除的元素:>");
                scanf("%d",&item);
                delete_val(&myList,item);
                break; 
            case 11:
                sort(&myList);
                return;
            case 12:
                reverse(&myList);
                return;
            case 13:
                clear(&myList);
                return;
            case 14:
                destory(&myList);
                return;
        }
    }
    return 0;
}