顺序表的增删改查及冒泡、选择排序、二分查找

最新推荐文章于 2020-03-02 19:18:17 发布
最新推荐文章于 2020-03-02 19:18:17 发布
阅读量276 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adzn1/article/details/79285256
版权

实现的功能：
1、初始化顺序表：

void SeqInit(SeqList* pSeq)
{
    pSeq->_size = 0;
    pSeq->_capicity = MAX;
    pSeq->_a = (DataType*)malloc(sizeof(DataType)*pSeq->_capicity);

    memset(pSeq->_a, 0, sizeof(DataType)*pSeq->_capicity);
}

2、打印顺序表：

void SeqPrint(SeqList* pSeq)
{
    size_t i=0;
    for(i=0;i<pSeq->_size;i++)
    {
        printf("%d ",pSeq->_a[i]);
    }
}

3、判满加扩容

SeqList* SeqCheckFull(SeqList* pSeq)
{
    assert(pSeq);
    if(pSeq->_size==pSeq->_capicity)
    {
        DataType *tmp=(DataType*)realloc(pSeq->_a,sizeof(DataType)*pSeq->_capicity*2);
        if(NULL==tmp)
        {
            printf("扩容失败\n");
            return NULL;
        }
        pSeq->_capicity=pSeq->_capicity*2;
        pSeq->_a=tmp;

    }
    return pSeq;



}

4、销毁

void SeqDestory(SeqList* pSeq)
{
    free(pSeq->_a);
    pSeq->_size=0;

}

5、任意位置插入：

void SeqInsert(SeqList* pSeq, size_t pos, DataType x)//任意插
{
    assert(pSeq);
    pSeq = SeqCheckFull(pSeq);
    if (pSeq != NULL)
    {
        if (0 == pSeq->_size)
        {
            pSeq->_a[pSeq->_size++] = x;

        }
        else
        {
            int end = pSeq->_size - 1;
            while (end >= (int)pos)
            {
                pSeq->_a[end + 1] = pSeq->_a[end];
                end--;
            }
            pSeq->_a[pos] = x;

            ++pSeq->_size;
        }
    }
}

6、任意位置删除

void SeqErase(SeqList* pSeq, size_t pos)//任意删除
{
    size_t begin=pos;
    assert(pSeq);
    assert(pos<pSeq->_size);
    if(pSeq->_size==0)
    {
        printf("此链表为空\n");
        return;
    }
    while((int)begin<pSeq->_size)
    {
        pSeq->_a[begin]=pSeq->_a[begin+1];
        begin++;
    }
    pSeq->_size--;




}

7、修改

void SeqAt(SeqList* pSeq, size_t pos, DataType x)//替换
{
         assert(pSeq);
         assert(pos<pSeq->_size);
         pSeq->_a[pos]=x;
}
void swap(DataType *x,DataType *y)
{
    *x^=*y;
    *y^=*x;
    *x^=*y;
}

8、查找

int SeqFind(SeqList* pSeq, DataType x)//查找
{
    size_t i;
    assert(pSeq);
    for(i=0;i<pSeq->_a[i];i++)
    {
        if(x==pSeq->_a[i])
        {
            return i;
        }
    }
    return -1;


}

9、冒泡

void BubbleSort(SeqList* pSeq)//冒泡排序
{
    size_t i=0;
    size_t j=0;

    for(i=0;i<pSeq->_size-1;i++)
    {
        int flag=0;
        for(j=0;j<pSeq->_size-1-i;j++)
        {
            if((pSeq->_a[j])>(pSeq->_a[j+1]))
            swap((&pSeq->_a[j]),(&pSeq->_a[j+1]));
            flag=1;
        }
        if(0==flag)
       {
        return;
        }
    }




}

10、选择

void SelectSort(SeqList* pSeq)//选择排序
{

    size_t begin=0;
    size_t end=pSeq->_size-1;

    assert(pSeq);
    while(begin<=end)
    {
    size_t min=begin;
    size_t max=begin;
    size_t i=begin;
    for(i=begin;i<=end;i++)
    {
        if(pSeq->_a[i]<pSeq->_a[min])
            min=i;

        if(pSeq->_a[i]>pSeq->_a[max])
            max=i;
    }   
        swap(&(pSeq->_a[begin]),&(pSeq->_a[min]));
        if(begin==max)
            max=min;
        swap(&(pSeq->_a[end]),&(pSeq->_a[max]));
         begin++;
         end--;
    }






}

11、二分

int BinarySearch(SeqList* pSeq, DataType x)
{
    int begin=0;
    int end=pSeq->_size-1;
    while(begin<=end)
    {
    int  mid=begin+((end-begin)>>1);
    if(pSeq->_a[mid]<x)
    {
        begin=mid+1;
    }
    else if(x<pSeq->_a[mid])
    {
        end=mid-1;
    }
    else
        return mid;
    }
    return -1;


}

整体代码：

SeqList.h

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#include <stdio.h>
#include <windows.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>

#define MAX 10

typedef int DataType; //类型重定义

typedef struct SeqList
{
    DataType* _a;
    size_t _size;
    size_t _capicity;
}SeqList;


void SeqPrint(SeqList* pSeq);  //打印
void SeqInit(SeqList* pSeq);   //初始化
void SeqDestory(SeqList* pSeq); //释放
SeqList* SeqCheckFull(SeqList* pSeq);//判满＋扩容

void SeqPushBack(SeqList* pSeq, DataType x); //尾插
void SeqPopBack(SeqList* pSeq);   //尾删
void SeqPushFront(SeqList* pSeq, DataType x); //头插
void SeqPopFront(SeqList* pSeq);  //头删

void SeqInsert(SeqList* pSeq, size_t pos, DataType x);//指定位置插入
void SeqErase(SeqList* pSeq, size_t pos);  //指定位置删除

int SeqFind(SeqList* pSeq, DataType x);   //查找指定元素
void SeqAt(SeqList* pSeq, size_t pos, DataType x); //替换指定位置元素

void BubbleSort(SeqList* pSeq); //冒泡排序
void SelectSort(SeqList* pSeq); //选择排序
int BinarySearch(SeqList* pSeq, DataType x); //二分查找

#endif

SeqList.c

#include"SeqList.h"
SeqList* SeqCheckFull(SeqList* pSeq)
{
    assert(pSeq);
    if(pSeq->_size==pSeq->_capicity)
    {
        DataType *tmp=(DataType*)realloc(pSeq->_a,sizeof(DataType)*pSeq->_capicity*2);
        if(NULL==tmp)
        {
            printf("扩容失败\n");
            return NULL;
        }
        pSeq->_capicity=pSeq->_capicity*2;
        pSeq->_a=tmp;

    }
    return pSeq;



}
void SeqDestory(SeqList* pSeq)
{
    free(pSeq->_a);
    pSeq->_size=0;

}
void SeqInit(SeqList* pSeq)
{
    pSeq->_size = 0;
    pSeq->_capicity = MAX;
    pSeq->_a = (DataType*)malloc(sizeof(DataType)*pSeq->_capicity);

    memset(pSeq->_a, 0, sizeof(DataType)*pSeq->_capicity);
}
void SeqPrint(SeqList* pSeq)
{
    size_t i=0;
    for(i=0;i<pSeq->_size;i++)
    {
        printf("%d ",pSeq->_a[i]);
    }
}
void SeqPushBack(SeqList* pSeq, DataType x)
{
    assert(pSeq);
    SeqInsert(pSeq, pSeq->_size, x);

}
void SeqPopBack(SeqList* pSeq)
{

    SeqErase(pSeq,pSeq->_size-1);
    /*if(pSeq->_size==0)
    {
        printf("此链表为空\n");
        return;
    }
    else
    {
        pSeq->_size--;
    }*/

}
void SeqPushFront(SeqList* pSeq, DataType x)
{
    assert(pSeq);
    SeqInsert(pSeq,0,x);

}
void SeqPopFront(SeqList* pSeq)
{
    assert(pSeq);


    /*size_t begin=1;
    assert(pSeq);

    if(pSeq->_size==0)
    {
        printf("此链表为空\n");
        return;
    }
    else
    {
       pSeq->_a[begin-1]=pSeq->_a[begin];
       begin++;
    }
    pSeq->_size--;*/
    SeqErase(pSeq,0);
}
void SeqInsert(SeqList* pSeq, size_t pos, DataType x)//任意插
{
    assert(pSeq);
    pSeq = SeqCheckFull(pSeq);
    if (pSeq != NULL)
    {
        if (0 == pSeq->_size)
        {
            pSeq->_a[pSeq->_size++] = x;

        }
        else
        {
            int end = pSeq->_size - 1;
            while (end >= (int)pos)
            {
                pSeq->_a[end + 1] = pSeq->_a[end];
                end--;
            }
            pSeq->_a[pos] = x;

            ++pSeq->_size;
        }
    }
}

void SeqErase(SeqList* pSeq, size_t pos)//任意删除
{
    size_t begin=pos;
    assert(pSeq);
    assert(pos<pSeq->_size);
    if(pSeq->_size==0)
    {
        printf("此链表为空\n");
        return;
    }
    while((int)begin<pSeq->_size)
    {
        pSeq->_a[begin]=pSeq->_a[begin+1];
        begin++;
    }
    pSeq->_size--;




}
int SeqFind(SeqList* pSeq, DataType x)//查找
{
    size_t i;
    assert(pSeq);
    for(i=0;i<pSeq->_a[i];i++)
    {
        if(x==pSeq->_a[i])
        {
            return i;
        }
    }
    return -1;


}
void SeqAt(SeqList* pSeq, size_t pos, DataType x)//替换
{
         assert(pSeq);
         assert(pos<pSeq->_size);
         pSeq->_a[pos]=x;
}
void swap(DataType *x,DataType *y)
{
    *x^=*y;
    *y^=*x;
    *x^=*y;
}
void BubbleSort(SeqList* pSeq)//冒泡排序
{
    size_t i=0;
    size_t j=0;

    for(i=0;i<pSeq->_size-1;i++)
    {
        int flag=0;
        for(j=0;j<pSeq->_size-1-i;j++)
        {
            if((pSeq->_a[j])>(pSeq->_a[j+1]))
            swap((&pSeq->_a[j]),(&pSeq->_a[j+1]));
            flag=1;
        }
        if(0==flag)
       {
        return;
        }
    }




}
void SelectSort(SeqList* pSeq)//选择排序
{

    size_t begin=0;
    size_t end=pSeq->_size-1;

    assert(pSeq);
    while(begin<=end)
    {
    size_t min=begin;
    size_t max=begin;
    size_t i=begin;
    for(i=begin;i<=end;i++)
    {
        if(pSeq->_a[i]<pSeq->_a[min])
            min=i;

        if(pSeq->_a[i]>pSeq->_a[max])
            max=i;
    }   
        swap(&(pSeq->_a[begin]),&(pSeq->_a[min]));
        if(begin==max)
            max=min;
        swap(&(pSeq->_a[end]),&(pSeq->_a[max]));
         begin++;
         end--;
    }






}
int BinarySearch(SeqList* pSeq, DataType x)
{
    int begin=0;
    int end=pSeq->_size-1;
    while(begin<=end)
    {
    int  mid=begin+((end-begin)>>1);
    if(pSeq->_a[mid]<x)
    {
        begin=mid+1;
    }
    else if(x<pSeq->_a[mid])
    {
        end=mid-1;
    }
    else
        return mid;
    }
    return -1;


}

test.c(测试部分）//此处列出部分测试函数

#include"SeqList.h"
SeqList L;
void test1()
{
    SeqInit(&L);
    SeqPushBack(&L,1);
    SeqPushBack(&L,2);
    SeqPushBack(&L,3);
    SeqPopBack(&L);
    SeqPopBack(&L);


    SeqPrint(&L);

}
void test3()
{
    SeqInit(&L);
    SeqPushFront(&L,1);
    SeqPushFront(&L,2);
    SeqPopFront(&L);


    SeqPrint(&L);
    printf("\n");
}
void test2()
{
    SeqInit(&L);
    SeqInsert(&L,0,1);
    SeqInsert(&L,0,1);
    SeqInsert(&L,1,2);
    SeqInsert(&L,2,20);
    SeqPrint(&L);
    printf("\n");
    printf("%d",SeqFind(&L,20));
    printf("\n");

    SeqAt(&L,1,4);
    SeqPrint(&L);
    /*SeqErase(&L,0);

    SeqPrint(&L);
    SeqErase(&L,1);
     printf("\n");
    SeqPrint(&L);
    printf("\n");*/
}
void test4()//冒泡
{
    SeqInit(&L);
    SeqPushBack(&L,3);
    SeqPushBack(&L,12);
    SeqPushBack(&L,4);
    SeqPushBack(&L,65);
    SeqPushBack(&L,32);
    SeqPushBack(&L,1);
    SeqPushBack(&L,9);
    SeqPrint(&L);
    printf("\n");
    BubbleSort(&L);

    SeqPrint(&L);
}
void test5()//二分法
{
    int ret=0;
    SeqInit(&L);
    SeqPushBack(&L,1);
    SeqPushBack(&L,2);
    SeqPushBack(&L,3);
    SeqPushBack(&L,4);
    SeqPushBack(&L,5);
    SeqPushBack(&L,6);
    SeqPushBack(&L,7);
    SeqPrint(&L);
     ret= BinarySearch(&L,7);
    printf("\n");


    if (-1 == ret)
    {
        printf("没找到\n");
    }
    else
    {
        printf("下标是%d\n", ret);
    }


}
void test6()//选择排序法
{

    SeqInit(&L);
    SeqPushBack(&L,4);
    SeqPushBack(&L,2);
    SeqPushBack(&L,1);
    SeqPushBack(&L,5);

    SeqPrint(&L);
    printf("\n");
    SelectSort(&L);
    SeqPrint(&L);


}
int main()
{

    test6();

    system("pause");
    return 0;
}
Antony12
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表的增删查改&&各类排序问题
zjx624bjh的博客
12-23 417
一，静态顺序表增删查改#define MAX_SIZE 10 typedef int DataType; typedef struct SeqList { DataType array[MAX_SIZE]; size_t size; }SeqList; void Print(SeqList* seq) { assert(seq); f
C+数据结构代码实例
04-18
.txt 乘方函数桃子猴.txt 乘法矩阵.txt 二分查找1.txt 二分查找2.txt 二叉排序树.txt 二叉树.txt 二叉树实例.txt 二进制数.txt 二进制数2.txt 余弦曲线.txt 余弦直线.txt 傻瓜递归.txt 冒泡排序.t xt 冒泡法改进.txt
顺序表的增删改查(包括顺序表的冒泡排序,顺序表的二分查找)
gp1330782530的博客
08-15 208
顺序表的增删改查(包括顺序表的冒泡排序,顺序表的二分查找) seqlist.h #ifndef _SEQLIST_H_ #define _SEQLIST_H_ #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> #include...
顺序表的底层实现（顺序表的增删改查，顺序表的冒泡排序，顺序表的二分查找）
gp1330782530的博客
03-02 357
顺序表的底层实现 1、顺序表的概念 顺序表是用一段物理地址连续的存储单元存储数据元素的线性结构，一般情况下采用数组存储。可以完成对数据的增删改查。 2、顺序表的结构 顺序表的结构有两种： 1、静态顺序表：使用定长数组存储 2、动态顺序表：使用动态开辟的数组存储 //顺序表的静态存储 #define N 100 typedef int SLDataType; typedef struct...
动态顺序表的增删改查及相关操作
Hb_key的博客
08-01 302
顺序表的概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储 // 顺序表的静态存储 #define N 100 typedef int DataType; typedef struct SeqLi...
顺序表的增、删、查、改、排序等各项操作
Tianzez的博客
12-10 661
实现功能： 1.打印顺序表 2.初始化顺序表 3.销毁顺序表 4.判满+扩容 5.尾部插入 6.尾部删除 7.头部插入 8.头部删除 9.指定位置插入 10.指定位置删除 11.查找指定元素 12.替换指定位置元素 13.冒泡排序 14.选择排序 15.二分查找 (1)SeqList.h（头文件）#ifndef
再写顺序表（c语言实现，外加冒泡排序，二分查找）
LXY的博客
10-03 921
概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。 头文件声明 SeqList.h #pragma once #include<stdbool.h> typedef int SDataType; /* //静态顺...
顺序表的基本操作，以及排序，二分查找等
小马同学的博客
11-14 278
arr.h文件 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<assert.h> #define maxsize 1 typedef int datetype; typedef struct seqlist { datetype *myarr; size_t si...
动态顺序表的基本接口，增删改查以及一般的排序查找
cat_want_fly的博客
01-13 123
 在学完动态顺序表后，我个人的理解就是动态顺序表就像是一包方便面， typedef struct seqlist//方便面的组成 { SLDataType *_arry;// 面饼 size_t _size;//有效数据个数，同时也是插入的下一个下标 面饼重量 size_t _capcity;//容量空间的大小 ...
动态顺序表的一些增、删、查、改、排序
HaloTrriger的博客
02-01 304
顺序表呢，是线性表的一种。 它用一段地址连续的存储单元依次存储数据元素的线性结构，地址空间是连续的，一般情况下采用数组，但数组有静态数组和动态数组， 所以顺序表分为：静态顺序表和动态顺序表。 今天写的这个呢是动态的顺序表，就是在静态基础上加了判满，扩容，销毁的函数。 功能如下： 链表开头插入，删除 链表尾部插入，删除 低效普通查找 ...
基于C++语言和单链表数据结构实现的通讯录管理系统，包含文件读取、文件保存、增删改查、排序、清空等功能.zip
12-14
本系统以C++语言为开发工具，利用单链表作为基础数据结构，提供了文件读取、文件保存、增删改查、排序以及清空等全面的功能。下面，我们将深入探讨这一系统的实现细节。 一、C++语言的选择 C++是一种通用的、面向...
2010年计算机二级考试大纲.pdf
10-02
- 常见的排序和查找算法，如交换类排序（冒泡、快速排序等）、选择类排序（选择、希尔排序等）、插入类排序（插入、希尔排序等）以及顺序查找和二分查找。 2. **程序设计基础**： - 程序设计方法和风格，强调结构...
2012级本数据结构实验教案.pdf
09-30
顺序表是数据结构中最基础的一种，通过数组实现，支持动态增删改查操作。实验中要求学生在TC环境下实现顺序表的动态操作，如插入、删除、查找和有序顺序表的合并。在顺序表中，插入或删除元素需要考虑元素的移动，这...
航班信息的查询与检索的程序设计模版
06-09
数组用于存储航班信息，链表用于已订票客户名单（便于按姓名排序和增删操作），队列用于管理候补客户（便于按需求顺序处理退票）。 - **指针**：在C语言或类似编程语言中，指针用于动态地访问和修改数据结构中的元素...
排序算法面试题（上）
adzn1的博客
03-04 2560
> 1、插入排序： 插入排序 基本思想： 每一步将一个待排序的元素，按其排序码的大小，插入到前面已经排好序的一组元素的合适位置上去，直到元素全部插完为止。 当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经 排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序 进行比较，找到插
哈希表（拉链法）
adzn1的博客
03-10 2090
> 开散列法又叫链地址法(开链法)。 开散列法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个 桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。 设元素的关键码为37, 25, 14, 36, 49, 68, 57, 11, 散列表为HT[12]，表的大小为12，散列函数为Hash(x) = x % 11
数据结构入门——时间复杂度和空间复杂度
adzn1的博客
12-09 803
> 1. 时间复杂度： 时间复杂度实际上就是一个函数，计算程序执行的总次数（不是计算时间，是计算语句执行次数）；** 在进行时间复杂度计算时要注意： 1）在实际中通常考虑的是算法运行的最坏情况； 2）关注运行时间的增长趋势，关注增长最快的项即可，其他可进行忽略 比如：F（n)=8*n^2+9*n+9;其时间复杂度为O（n^2); 3)递归算法的时间复杂度
数据结构：堆及堆的应用
adzn1的博客
02-25 381
> 1. 堆：把一组数据按照完全二叉树的顺序储存模式存储在一个二维数组中， > 若ai<ai+1&&ai<ai+2,则称为小堆， > 若ai>ai+1&&ai>ai+2,则称为大堆（i=0，1，2...n); 堆的特点: 大堆：任意一个节点的值都比它的左右孩子节点的值大，且逐级递减； 小堆：任意一个节点的值都比它的左右孩子节点的值小，且逐级递增； 在堆中，若设父
算法赏析：二分查找与冒泡排序解析
课程涵盖计算机基础、数据结构、算法简介等内容，特别关注二分查找和冒泡排序。二分查找是一种高效的查找算法，适用于有序数据，通过不断缩小查找范围来定位目标元素。冒泡排序则是一种简单的排序算法，通过不断交换...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值