顺序表操作（C语言）含注释

基础题：

1、显示

2、插入

3、查找（显示比较次数）

4、删除（显示移动次数）

5、排序（普通、快速，显示比较次数、移动次数）

6、折半查找（显示比较次数）

7、编程实现一个顺序表的就地逆置，即利用原表的存储空间将顺序表逆置。

提高题：

8*、要求以较高的效率实现删除顺序表中元素值在x到y(x和y自定)之间的所有元素。

扫描二维码关注公众号，回复： 17324795 查看本文章

[解题思路] 在顺序表中设置两个初值为0的下标变量i和j，其中，i为比较元素的下标，j为赋值元素的下标。依次取顺序表中下标为i的元素与x和y比较，假若是x到y之外的元素，则赋值给下标为j的元素。这种算法比删除一个元素后立即移动其后面的元素的效率高得多。

9*、编程实现将两个有序的顺序表进行合并，要求同样的数据元素只出现一次。

[解题思路] 由于两个顺序表中的元素呈有序排列，在进行合并的时候，依次比较，哪个顺序表的元素值小，就先将这个元素复制到新的顺序表中，若两个元素相等，则复制一个即可，这样一直到其中的一个顺序表结束，然后将剩余的顺序表复制到新的顺序表中即可。

10*、有序插入（显示比较次数、移动次数），

屏幕提示后，从键盘输入一个元素值，在经过排序的线性表中插入这个元素；

屏幕显示比较次数和移动次数，应有溢出判断和报告。

顺序表操作菜单如下图所示:

其中初始化代码已给出：

//屏幕提示后，从键盘输入线性表长度和随机数种子，生成指定长度的线性表list
void init(SqList &list)
{
    int i;
    while (1) {
        printf("输入元素个数（0－%d）：", MaxSize);
        scanf("%d", &list.len);
        if (list.len >= 0 && list.len <= MaxSize)    
            break;
        printf("\n");
    }
    while (1) {
        printf("输入随机数种子（0－32767）：");
        scanf("%d", &i);
        if (i >= 0 && i <= 32767)    
            break;
        printf("\n");
    }
    srand(i);    //指定随机数种子，相同的种子将产生相同的数据序列
    rand();

    for (i = 0; i < list.len; i++)    //将len个元素填充随机数
        list.data[i] = rand() % 10000;
    for (i = list.len; i < MaxSize; i++)//将余下的元素用0初始化（感觉不是很有必要）
        list.data[i] = 0;
    printf("初始化完毕。\n");
}

全部代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <iostream>
#include<iomanip>
#include<string.h>
using namespace std;
#define MaxSize 500
//定义顺序表结构
struct SqList{
    int data[MaxSize];
    int len;
};

void init(SqList &list);
void display(SqList &list);
void insert(SqList &list);
void search(SqList &list);
void del(SqList &list);
void simpleSort(SqList &list);
void quickSort(SqList &list,int low,int high);
void binarySearch(SqList &list);
void reverse(SqList &list);
void deleteX_Y(SqList &list);
void merge(SqList &list1);
void sqInsert(SqList &list);

SqList list;

int count1=0;//比较次数
int count2=0;//移动次数

int main()
{
    char choice;

    while (1) {
        system("cls");
        printf("\n\n\n\n");
        printf("\t\t            静态线性表操作  \n");
        printf("\t\t======================================");
        printf("\n\n");
        printf("\t\t             1：初始化      \n");
        printf("\t\t             2：显示        \n");
        printf("\t\t             3：单个插入    \n");
        printf("\t\t             4：查找        \n");
        printf("\t\t             5：删除        \n");
        printf("\t\t             6：简单排序    \n");
        printf("\t\t             7：快速排序    \n");
        printf("\t\t             8：折半查找    \n");
        printf("\t\t             9：顺序表逆置  \n");
        printf("\t\t             a：删除区间值  \n");
        printf("\t\t             b：合并两有序表 \n");
        printf("\t\t             c：有序插入    \n");
        printf("\t\t             0：退出        \n");
        printf("\n");
        printf("\t\t请选择：");
        choice = getch();
        system("cls");
                
        switch(choice)
        {
            case '1':
                init(list);
                system("pause");
                break;
            case '2':
                display(list);
                system("pause");
                break;
            case '3':
                insert(list);
                system("pause");
                break;
            case '4':
                search(list);
                system("pause");
                break;
            case '5':
                del(list);
                system("pause");
                break;
            case '6':
                simpleSort(list);
                system("pause");
                break;
            case '7':
                count1=count2=0;//重置
                quickSort(list,0,list.len-1);
                printf("比较次数为：%d，移动次数为：%d\n",count1,count2);
                count1=count2=0;//重置
                system("pause");
                break;
            case '8':
                binarySearch(list);
                system("pause");
                break;
            case '9':
                reverse(list);
                system("Pause");
                break;
            case 'a':
                deleteX_Y(list);
                system("pause");
                break;
            case 'b':
                merge(list);
                system("pause");
                break;
            case 'c':
                sqInsert(list);
                system("pause");
                break;
            case '0':
                exit(0);
        }
    }
    return 0;
}



//屏幕提示后，从键盘输入线性表长度和随机数种子，生成指定长度的线性表list
void init(SqList &list)
{
    int i;
    while (1) {
        printf("输入元素个数（0－%d）：", MaxSize);
        scanf("%d", &list.len);
        if (list.len >= 0 && list.len <= MaxSize)    
            break;
        printf("\n");
    }
    while (1) {
        printf("输入随机数种子（0－32767）：");
        scanf("%d", &i);
        if (i >= 0 && i <= 32767)    
            break;
        printf("\n");
    }
    srand(i);    //指定随机数种子，相同的种子将产生相同的数据序列
    rand();

    for (i = 0; i < list.len; i++)    //将len个元素填充随机数
        list.data[i] = rand() % 10000;
    for (i = list.len; i < MaxSize; i++)//将余下的元素用0初始化（感觉不是很有必要）
        list.data[i] = 0;
    printf("初始化完毕。\n");
}

//在屏幕上依次显示线性表list中的元素个数和全部元素
//格式应便于观察
//如果需要指定输出的宽度，可以使用 cout << setw(W) << X ，其中 X 是输出的数值，W 是占据的列数
void display(SqList &list)
{
    printf("元素个数：%d\n元素为：\n",list.len);
    int i;
    for(i=0;i<list.len;i++)
    {
        cout <<setiosflags(ios::left)/*左对齐*/<< setw(15) << list.data[i];
        if((i+1)%10==0) printf("\n");
    }
    printf("\n");
}

//屏幕提示后，从键盘输入一个元素值，然后把这个新元素插到线性表list的末尾
//应有溢出判断和报告
void insert(SqList &list)
{
    int i,newelem;
    if(list.len>=MaxSize)
    {
        printf("线性表长度溢出，插入失败！\n");
        return;
    }
    printf("请输入新插入元素：");
    scanf("%d",&newelem);
    list.data[list.len]=newelem;
    list.len+=1;
}

//屏幕提示后，从键盘输入一个元素值，在线性表list中搜索这个元素
//屏幕显示搜索结果和搜索过程中的比较次数
void search(SqList &list)
{
    int elem,i=0,count=1,flag=0;
    printf("请输入要查找的元素值：");
    scanf("%d",&elem);
    for(i=0;i<list.len;i++,count++)
    {
        if(elem==list.data[i])
        {
            printf("元素位置为：%d，共比较%d次\n",i,count);
            flag=1;
        }
    }
    if(flag==0) printf("顺序表无此元素！\n");
}

//屏幕提示后，从键盘输入一个元素值，在线性表list中删除这个元素
//屏幕显示删除成功与否的信息，并显示比较次数和移动次数
void del(SqList &list)
{
    int delelem,i,j,flag=0/*有无删除*/;
    int count1=1;//比较次数
    printf("请输入要删除元素值：");
    scanf("%d",&delelem);
    for(i=0;i<list.len;i++,count1++)
    {
        if(list.data[i]==delelem)
        {
            int count2=0;//移动次数
            for(j=i;j<list.len-1;j++)//删除元素并移动1
            {
                list.data[j]=list.data[j+1];
                count2++;
            }
            flag=1;
            list.len--;//表长-1
            i--;//变量i需回退1，因为元素位置移动了！
            printf("删除成功！比较次数为：%d 移动次数：%d\n",count1,count2);
        }
    }
    if(flag==0) printf("删除失败！无此元素\n");
}

//对线性表list进行简单排序
//屏幕显示比较次数和移动次数
void simpleSort(SqList &list)//选择排序
{
    int i,j,k,temp;
    count1=0;//比较次数
    count2=0;//移动次数
    for(i=0;i<list.len;i++)
    {
        k=i;
        for(j=i+1;j<list.len;j++)
        {
            if(list.data[j]<list.data[k])
                k=j;
            count1++;
        }
        if(k!=i)
        {
            count2++;
            temp=list.data[i];
            list.data[i]=list.data[k];
            list.data[k]=temp;
        }
    }
    printf("比较次数为：%d，移动次数为：%d\n",count1,count2);
    count1=count2=0;//重置
}

//对线性表list进行快速排序
//屏幕显示比较次数和移动次数
void quickSort(SqList &list,int low,int high)
{
    if(low>high)
        return;
    int temp=list.data[low];//设定基准数
    int i=low;//左指针
    int j=high;//右指针
    while(i!=j)//开始查找
    {
        while(list.data[j]>=temp&&j>i)//先从右边开始
        {
            j--;
            count1++;
        }
        count1++;
        while(list.data[i]<=temp&&j>i)//再从左边开始
        {
            i++;
            count1++;
        }
        count1++;
        if(j>i)//交换两个数在线性表的位置
        {
            int t=list.data[i];
            list.data[i]=list.data[j];
            list.data[j]=t;
            count2++;
        }
    }
    if(list.data[low]!=list.data[i])
        count2++;
    list.data[low]=list.data[i];//将基准数归位
    list.data[i]=temp;
    quickSort(list,low,i-1);//递归处理左边
    quickSort(list,i+1,high);//递归处理右边
}

//屏幕提示后，从键盘输入一个元素值，对经过排序的线性表list进行折半查找
//屏幕显示查找结果，并显示比较次数
void binarySearch(SqList &list)
{
    /*low指向表首*/
    int low=0;
    /*high指向表尾*/
    int high=list.len-1;
    int mid;
    int elem,flag=0;
    count1=0;//重置比较次数
    printf("请输入要查找的元素值：");
    scanf("%d",&elem);
    while(low<=high)
    {
        mid=(low+high)/2;
        if(list.data[mid]==elem)
        {
            flag=1;
            count1++;
            printf("已查询到该元素位置为%d\n",mid);
            return;
        }
        else if(list.data[mid]>elem)
        {
            high=mid-1;
            count1++;
        }
        else
        {
            low=mid+1;
            count1++;
        }
    }
    if(flag==0)
        printf("顺序表无此元素！\n");
    count1=0;
}

//编程实现一个顺序表的就地逆置，即利用原表的存储空间将顺序表逆置
void reverse(SqList &list)
{
    int i;
    //临时交换
    int temp;
    printf("逆置前：\n");
    display(list);
    for(i=0;i<(list.len+1)/2;i++)
    {    //三角交换
        temp=list.data[i];
        list.data[i]=list.data[list.len-i-1];
        list.data[list.len-i-1]=temp;
    }
    printf("逆置后：\n");
    display(list);
}

//要求以较高的效率实现删除顺序表中元素值在x到y(x和y自定)之间的所有元素
/*[解题思路]  在顺序表中设置两个初值为0的下标变量i和j，其中，i为比较元素的下标，j为赋值元素的下标。
依次取顺序表中下标为i的元素与x和y比较，假若是x到y之外的元素，则赋值给下标为j的元素。
这种算法比删除一个元素后立即移动其后面的元素的效率高得多。*/
void deleteX_Y(SqList &list)
{
    //下标
    int i=0,j=0;
    //区间
    int x,y;
    //初始长度
    int len=list.len;
    printf("请输入区间x、y（以空格分开）：");
    scanf("%d %d",&x,&y);
    int delelem;
    printf("删除前：\n");
    display(list);
    for(;i<len;i++)
    {
        if(list.data[i]<x||list.data[i]>y)
        {
            list.data[j]=list.data[i];
            j++;
        }
        else
            list.len--;
    }
    printf("删除后：\n");
    display(list);
}

//编程实现将两个有序的顺序表进行合并，要求同样的数据元素只出现一次
/*[解题思路]  由于两个顺序表中的元素呈有序排列，在进行合并的时候，依次比较，
哪个顺序表的元素值小，就先将这个元素复制到新的顺序表中，若两个元素相等，则复制一个即可，
这样一直到其中的一个顺序表结束，然后将剩余的顺序表复制到新的顺序表中即可。*/
void merge(SqList &list)
{
    SqList list2,list3;
    printf("请设置顺序表2：\n");
    init(list2);
    quickSort(list2,0,list2.len-1);
    quickSort(list,0,list.len-1);
    memset(list3.data,0,sizeof(list3.data));
    system("cls");
    int i=0,j=0,k=0; 
    while((i<list.len)&&(j<list2.len))//控制范围
    {
        if(list.data[i]==list2.data[j])//相等，直接存入list3
        {
            list3.data[k]=list2.data[j];
            i++;
            j++;
        }
        else if(list.data[i]<list2.data[j])
        {
            list3.data[k]=list.data[i];
            i++;
        }
        else
        {
            list3.data[k]=list2.data[j];
            j++;
        }
        k++;
    }
    if(i>=list.len)//尾部处理
        for(i=j;i<list2.len;i++)
        {
            list3.data[k]=list2.data[i];
            k++;
        }
    else
        for(j=i;j<list.len;j++)
        {
            list3.data[k]=list.data[j];
            k++;
        }
    list3.len=k;
    printf("顺序表1：\n");
    display(list);
    printf("顺序表2：\n");
    display(list2);
    list=list3;//将list3存入list
    printf("\n合并完成！\n\n");
    printf("新顺序表：\n");
    display(list);
}

//有序插入（显示比较次数、移动次数）
/* 屏幕提示后，从键盘输入一个元素值，
在经过排序的线性表中插入这个元素；屏幕显示比较次数和移动次数，
应有溢出判断和报告。*/
void sqInsert(SqList &list)
{
    int newelem;
    if(list.len>=MaxSize)
    {
        printf("长度溢出\n");
        return;
    }
    printf("请输入新插入元素：");
    scanf("%d",&newelem);
    quickSort(list,0,list.len-1);
    list.len++;//长度+1
    system("cls");
    count1=0;count2=0;//重置次数
    int i,j,temp;
    for(i=0;i<list.len;i++)
    {
        count1++;
        if(list.data[i]>=newelem)//找到以后
        {
            for(j=list.len;j>i;j--)
            {
                list.data[j]=list.data[j-1];
                count2++;
            }
            list.data[i]=newelem;
            printf("插入成功！\n");
            printf("比较次数为：%d，移动次数为：%d\n",count1,count2);
            display(list);
            count1=0;count2=0;//重置次数
            return;
        }
    }
}