顺序表的基本操作

最新推荐文章于 2024-07-18 13:20:33 发布
自律且java
最新推荐文章于 2024-07-18 13:20:33 发布
阅读量173
点赞数 2
分类专栏：数据结构文章标签：数据结构
本文链接：https://blog.csdn.net/weixin_55152875/article/details/120145803
版权
数据结构专栏收录该内容
2 篇文章 0 订阅
订阅专栏
顺序表的基本操作

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;	//自定义数据类型
/*
    遍历顺序表
*/
void printList(ElemType pList[],int length)
{
    for(int i = 0;i < length;i++)
    {
        printf("%d ",pList[i]);//打印每个元素
    }
    printf("\n");
}
/*
    静态初始化线性表
*/
#define MAX_SIZE 10
typedef struct SeqList
{
    ElemType pList[MAX_SIZE];
    int length;
}SeqList;		//定义结构体
void initList(SeqList &L)
{
    ElemType enterData;
    L.length = 0;//顺序表初始元素个数为0
    while(scanf("%d",&enterData) && enterData < 99999)
    {
        L.pList[L.length++] = enterData;	//给线性表赋初值并更新顺序表有效元素个数
    }
}
/*
    动态初始化线性表
*/
#define INIT_SIZE 100
#define INCRE_SIZE 10
typedef struct SqList
{
    ElemType *pList;
    int length;
    int listSize;
}SqList;	//定义结构体
void initList(SqList &L)
{
    L.pList = (ElemType *)malloc(INIT_SIZE * sizeof(ElemType));//malloc函数申请空间
    L.length = 0;//顺序表初始元素个数为0
    ElemType enterData;
    while(scanf("%d",&enterData) && enterData < 99999)
    {
        L.pList[L.length++] = enterData;	//手动输入数据,并更新有效数据个数
    }
    L.listSize = INIT_SIZE;		//顺序表当前最大容量
}
/*
    在第 i 个元素前插入元素 e
*/
void insertIthElem(SqList &L,int i,ElemType e)
{
    if(i > 0 && i <= L.length && L.length < L.listSize)	//判断i值是否合法
    {
        for(int curIndex = L.length - 1;curIndex >= i - 1;curIndex--)//寻找 i 的位置
        {
            L.pList[curIndex + 1] = L.pList[curIndex];//非i位置,元素后移操作
        }
        L.pList[i-1] = e;//在第i个元素前插入 e
        L.length += 1;//更新元素个数
    }
}
/*
    删除第 i 个元素 , 并用 e 返回
*/
ElemType deleteIthElem(SqList &L,int i,ElemType &e)
{
    if(i > 0 && i <= L.length)
    {
        e = L.pList[i-1];
        for(int curIndex = i;curIndex < L.length;curIndex++)//寻找 i 的位置
        {
            L.pList[curIndex - 1] = L.pList[curIndex];//删除第i个元素
        }
        L.length -= 1;//更新元素个数
    }
    return e;
}
/*
    顺序表按位查找
*/
//按位查找 返回查找的值
int getElem(SqList L,int i)
{
    return L.pList[i-1];	//返回第i个位置的值
}
/*
    顺序表按值查找
*/
//按值查找,返回查找的位置
int getElemIth(SqList L,ElemType e)
{
    for(int curIndex = 0;curIndex < L.length;curIndex++)
    {
        if(L.pList[curIndex] == e)//寻找值为e的位置
        {
            return curIndex + 1;//若找到返回位序
        }
    }
    return -1;//找不到返回-1
}
/*
    在顺序表中删除最小元素空出的位置由最后一个元素填补
*/
void deleteMinElem(SqList &L)
{
    int minIndex = 0;       //用最小元素的下标就可以表示 最小元素的值 与 最小元素的位置
    for(int curIndex = 1;curIndex < L.length;curIndex++)
    {
        if(L.pList[curIndex] < L.pList[minIndex])
        {
            minIndex = curIndex;//寻找最小元素下标
        }
    }
    L.pList[minIndex] = L.pList[L.length - 1];//删除最小元素,并由最后一个元素填补
    L.length -= 1;//更新元素个数
}
/*
    在无序顺序表中删除值在 s 和 t 之间所有元素
*/
void deleteDisorderElemST(SqList &L,ElemType s,ElemType t)
{
    int curLength = 0;		//新表当前元素个数
    int curIndex = 0;		//当前下标
    while(curIndex < L.length)
    {
        int e = L.pList[curIndex];
        if(e < s || e > t)//寻找值小于s 或 大于t的元素
        {
            L.pList[curLength++] = e;//将满足条件的元素放入新表
        }
        curIndex++;	//更新新表当前元素个数
    }
    L.length = curLength;//更新新表长度
}
/*
    在非递减顺序表中删除值在[s,t]区间的所有元素
*/
void deleteOrderElemST(SqList &L,ElemType s,ElemType t)
{
    int curIndex = 0;	//当前下标
    int curLength = 0;	//新表当前元素个数
    while(curIndex < L.length)	//寻找值小于s 大于t 的元素,放入新表末尾
    {
        if(L.pList[curIndex] < s)
        {
            curLength = curIndex + 1;
        }
        else if(L.pList[curIndex] > t)
        {
            L.pList[curLength++] = L.pList[curIndex];
        }
        curIndex++;	//更新新表当前元素个数
    }
    L.length = curLength;//更新新表长度
}
/*
    删除非递减顺序表L中的重复元素
*/
void deleteRepeatElem(SqList &L)
{
    int curIndex = 1;	//当前下标
    int curLength = 1;	//新表当前元素个数
    while(curIndex < L.length)//寻找与新表最后一个元素不同的元素,追加新表末尾
    {
        if(L.pList[curIndex] > L.pList[curLength - 1])
        {
            L.pList[curLength++] = L.pList[curIndex];
        }
        curIndex++;
    }
    L.length = curLength;	//更新新表长度
}
/*
    顺序表 A , m 个元素 , 升序 不存在相同元素
    顺序表 B , n 个元素 , 降序 不存在相同元素
    (1) 两表升序合并在表 C 中
    (2) 表 A 有 m + n 个存储空间,将 A B 两表合并在表 A 中
    (3) 表 A 前 r 个元素递增有序,而表 A 中后 m - r 个元素递减有序,将表 A 进行升序排序 //直接选择排序
*/
//(1)
void mergeABToC(SqList &La,SqList &Lb,SqList &Lc)
{
    Lc.length = La.length + Lb.length;
    Lc.pList = (ElemType *)malloc(sizeof(ElemType) * (Lc.length));//C表申请空间
    int curLength = 0;	//C表当前元素个数
    int indexLa = 0;	//A表当前下标
    int indexLb = Lb.length - 1;	//B表当前下标
    while(curLength < Lc.length)
    {
        while(indexLa < La.length && indexLb >= 0)//寻找A B表中最小元素追加在C表末尾
        {
            if(La.pList[indexLa] < Lb.pList[indexLb])
            {
                Lc.pList[curLength++] = La.pList[indexLa++];
            }
            else
            {
                Lc.pList[curLength++] = Lb.pList[indexLb--];
            }
        }
        while(indexLa < La.length)//若A表还有剩余元素,则追加到C表末尾
        {
            Lc.pList[curLength++] = La.pList[indexLa++];
        }
        while(indexLb >= 0)//若B表还有剩余元素,则追加到C表末尾
        {
            Lc.pList[curLength++] = Lb.pList[indexLb--];
        }
    }
    free(La.pList);         //释放A表
    La.length = 0;
    La.listSize = 0;
    free(Lb.pList);		//释放B表
    Lb.length = 0;
    Lb.listSize = 0;
}
//(2)
void mergeABToA(SqList &La,SqList &Lb)
{
    int indexLa = La.length - 1;	//A表当前下标
    int indexLb = 0;		//B表当前下标
    La.length = La.length + Lb.length;	//合并后A表总长度
    int curIndex = La.length - 1;	//合并后新表当前下标
    while(curIndex >= 0)
    {
        while(indexLa >= 0 && indexLb < Lb.length)//寻找A B表中最大者从合并后的A表末尾按序插入
        {
            if(La.pList[indexLa] > Lb.pList[indexLb])
            {
                La.pList[curIndex--] = La.pList[indexLa--];
            }
            else
            {
                La.pList[curIndex--] = Lb.pList[indexLb++];
            }
        }
        while(indexLa >= 0)//若A 表中有剩余元素,继续按序插入合并后的A表
        {
            La.pList[curIndex--] = La.pList[indexLa--];
        }
        while(indexLb < Lb.length)//若B表中有剩余元素,按序插入合并后的A表
        {
            La.pList[curIndex--] = Lb.pList[indexLb++];
        }
    }
    free(Lb.pList);//释放B表
    Lb.length = 0;
    Lb.listSize = 0;
}
//(3)
void sortListA(SqList &La,int r)
{
    int curIndex = r;	//A表当前下标
    while(curIndex < La.length)//从第r个元素开始以后的元素选用直接插入排序
    {
        int e = La.pList[curIndex];
        int i = curIndex;
        while(i > 0 && La.pList[i - 1] > e)
        {
            La.pList[i ] = La.pList[i-1];//寻找插入位置
            i--;
        }
        La.pList[i] = e;//进行插入
        curIndex++;
    }
}
/*
    给定两个非空集合A和B,分别用升序顺序表La和Lb存储,设计算法求解A∩B
*/
void mergeAB(SqList &La,SqList &Lb)
{
    int curLength = 0;	//新表当前元素个数
    int indexLa = 0;	//A的当前下标
    int indexLb = 0;	//B的当前下标
    while(indexLa < La.length && indexLb < Lb.length)
    {
        if(La.pList[indexLa] < Lb.pList[indexLb])//若B元素大于A元素,A指向下一个元素
        {
            indexLa++;		
        }
        else if(La.pList[indexLa] > Lb.pList[indexLb])//若A元素大于B元素,B指向下一个元素
        {
            indexLb++;
        }
        else	//若 A B 元素相等
        {
            La.pList[curLength++] = La.pList[indexLa];//追加到新表末尾
            indexLa++;
            indexLb++;
        }
    }
    La.length = curLength;//更新新表长度
}
/*
    给定两个非空集合A和B,分别用升序顺序表La和Lb存储,设计算法求解A-B
        比较两个表中的数,如果 A 中的小于 B 中的,则将数 在 A 中从开头开始存,知道 A 表或 B 表为空
        若 B 表为空,则将 A 中剩余的数全都存在 A 中
            更好地运用空间
*/
void except(SqList &La,SqList &Lb)
{
    int curLength = 0;	//新表当前元素个数
    int indexLa = 0;	//A当前下标
    int indexLb = 0;	//B当前下标
    while(indexLa < La.length && indexLb < Lb.length)
    {
        if(La.pList[indexLa] < Lb.pList[indexLb])//A元素小于B元素
        {
            La.pList[curLength++] = La.pList[indexLa++];//追加到新表末尾,更新新表当前元素个数
        }
        else if(La.pList[indexLa] > Lb.pList[indexLb])//A元素大于B元素
        {
            indexLb++;			//B指向下一个元素
        }
        else		//A B 元素相等 ,A B 都指向下一个元素
        {
            indexLa++;
            indexLb++;
        }
    }
    La.length = curLength;//更新新表长度
}
/*
    设计算法逆置顺序表L
*/
void reverseL(SqList &L)
{
    int low = 0;	//低位
    int high = L.length - 1;//高位
    while(low < high)//若低位小于高位,交换二者数据
    {
        int temp = L.pList[low];
        L.pList[low] = L.pList[high];
        L.pList[high] = temp;
        low++;
        high--;
    }
}
/*
    将序列L循环左移动 r
*/
void reverseList(SqList &L,int low,int high)
{
    while(low < high)
    {
        int temp = L.pList[low];
        L.pList[low] = L.pList[high];
        L.pList[high] = temp;
        low++;
        high--;
    }
}
void leftMove(SqList &L,int r)
{
    reverseList(L,0,L.length - 1);
    reverseList(L,0,L.length - r - 1);
    reverseList(L,L.length - r,L.length - 1);
}
/*
    将序列L循环右移动 r
*/
void rightMove(SqList &L,int r)
{
    reverseList(L,0,L.length - 1);
    reverseList(L,0,r-1);
    reverseList(L,r,L.length - 1);
}
自律且java
关注
2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
顺序表的基本操作

顺序表的基本操作#include <stdio.h>#include <stdlib.h>typedef int ElemType; //自定义数据类型/* 遍历顺序表*/void printList(ElemType pList[],int length){ for(int i = 0;i < length;i++) { printf("%d ",pList[i]);//打印每个元素 } printf("
复制链接

扫一扫