数据结构01 时间复杂度及线性表的各功能源码

输入、输出：有穷，确定，可行

算法效率的度量方法：

以最高阶 去除其余加项，去除系数

• 时间复杂度排序：

O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n³) < O(2ⁿ)<O(n!)<O(nⁿ)

线性表

• Operation

//对象：线性表内容
  InitList(*L)://建立空线性表L，并进行初始化
  ClearList(*L)://清空线性表
  ListInsert(*L,i,x)://在线性表L第i个位置插入元素x
  ListDelete(*L,i,*e)://删除线性表L第i个元素，并将此元素赋值给e   
                               //需要进行赋值，所以（*e）指向内容
//对象：线性表指针
  ListEmpty(L)://判断线性表L是否为空表，空则返回true，否则返回false
  ListLength(L)://返回线性表元素个数
  LocateElem(L,x)://在线性表L中定位元素x的序号，作为返回值，若无x元素则返回0
  GetElem(L,i,*e)://把线性表L中第i个元素值赋值给e
                              //需要进行赋值，所以（*e）指向内容

Tips：对线性表进行数据操作的，则操作对象都为指针L指向的内容（*L）
若只是查询等，不对数据进行改动的，则操作对象都为指针L

//实现顺序表的建立、初始化、插入、删除、修改、普通合并、有序合并
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int ElemType;
ElemType *newbase;
//顺序表结构描述
typedef struct{
    ElemType *elem;    //基地址指针
    int length;        //顺序表长度，数据元素个数
    int ListSize;    //存储空间
}SqList;
//顺序表初始化
int InitSqList(SqList &L){
    L.elem=(ElemType *)malloc(sizeof(ElemType)*LIST_INIT_SIZE);//分配存储空间
    if(!L.elem)
        exit(OVERFLOW);//分配存储空间失败
    L.length=0;            //初始长度为0
    L.ListSize=LIST_INIT_SIZE;   //初始空间
    return OK;
}
//创建顺序表
void CreatSqList(SqList &L){
    int i,n;
    cout<<"请输入顺序表的元素个数:";
    cin>>n;
    for(i=0;i<n;i++){
        cout<<"请输入第 "<<(i+1)<<" 个元素:";
        cin>>L.elem[i];
        L.length++;
    }
}
//顺序表的显示
void ShowSqList(SqList &L){
    cout<<endl;
    for(int i=0;i<L.length;i++)
        cout<<L.elem[i]<<" ";
    cout<<endl;
}
//顺序表的插入
int InsertSqList(SqList &L,int pos,ElemType elem){//在顺序表中的pos位置插入elem元素
    if((pos-1)<0&&pos>L.length+1){//判断位置是否合法
        cout<<"您所插入的位置不合法！"<<endl;
        return ERROR;
    }
    if(L.length>=L.ListSize){/* realloc可以对给定的指针所指的空间进行扩大或者缩小，无论是扩张或是缩小，原有内存的中内容将保持不变。
            当然，对于缩小，则被缩小的那一部分的内容会丢失。realloc 并不保证调整后的内存空间和原来的内存空间保持同一内存地址。
            相反，realloc 返回的指针很可能指向一个新的地址。所以在代码中，我们必须将realloc返回的值，重新赋值给newbase*/
        newbase=(ElemType *)realloc(L.elem,(L.ListSize+LISTINCREMENT)*sizeof(ElemType));
        if(!newbase)
            exit(OVERFLOW);//内存分配失败
        L.elem=newbase;
        L.ListSize+=LISTINCREMENT;
    }
    for(int i=L.length-1;i>=pos-1;i--){
        L.elem[i+1]=L.elem[i];
    }
    L.elem[pos-1]=elem;
    L.length++;//表长加1
    return OK;
}
//顺序表的删除
int DeleteSqList(SqList &L,int pos){//顺序表中删除pos位置的元素
    if(pos<1||pos>L.length){
        cout<<"删除的位置不合法！"<<endl;
        return ERROR;
    }
    for(int i=pos-1;i<L.length;i++){
        L.elem[i]=L.elem[i+1];
    }
    L.length--;//表长减1
    return OK;
}
//修改顺序表
int UpdateSqList(SqList &L,int pos,ElemType elem){//在顺序表pos位置修改元素
    if(pos<1&&pos>L.length){
        cout<<"修改的位置不合法!"<<endl;
        return ERROR;
    }
    L.elem[pos-1]=elem;
    return 0;
}
//顺序表的合并
void CombineSqList(SqList &La,SqList &Lb){
    int i,j;
    for(i=0;i<Lb.length;i++){
        int cout=0;
        for(j=0;j<La.length;j++){
            if(La.elem[j]==Lb.elem[j])
                cout++;
        }
        if(cout==0)
            La.elem[La.length++]=Lb.elem[i];
    }
}
//顺序表的有序合并,有序合并的前提，两个顺序表已经排序好的
void CombineSq(SqList &LA,SqList &LB,SqList &LC){//LA,LB是递增排序的
    ElemType *pa,*pb,*pc,*pa_last,*pb_last;
    LC.length=LA.length+LB.length;//新表的长度为两个表的长度之和
    LC.elem=new ElemType[LC.length];//分配空间
    //LC.elem=(ElemType *)malloc(LC.length*sizeof(ElemType));
    pc=LC.elem;//分别指向第一个元素
    pa=LA.elem;
    pb=LB.elem;
    pa_last=LA.elem+LA.length-1;//指向最后一个元素
    pb_last=LB.elem+LB.length-1;
    while((pa<=pa_last)&&(pb<=pb_last)){
        if(*pa<=*pb)
            *pc++=*pa++;//就行比较然后就行赋值
        else
            *pc++=*pb++;
    }
    while(pa<=pa_last)
        *pc++=*pa++;//把剩下的逐一插入
    while(pb<=pb_last)
        *pc++=*pb++;
}
int main(){
    SqList L;
    InitSqList(L);
    CreatSqList(L);
    ShowSqList(L);
    int num=0;
    cout<<endl<<"1、插入"<<endl;
    cout<<"2、删除"<<endl;
    cout<<"3、修改"<<endl;
    cout<<"4、顺序表普通合并"<<endl;
    cout<<"5、顺序表有序合并"<<endl<<endl;
    cout<<"请选择需要进行的操作：";
    cin>>num;
    if(num<1||num>5){
        cout<<"你选择的操作不存在，请重新输入：";
        cin>>num;
    }
    switch(num){
        case 1:{
            int m,n;
            cout<<"请输入你要插入的位置：";
            cin>>m;
            cout<<"请输入你要插入的元素：";
            cin>>n;
            InsertSqList(L,m,n);
            ShowSqList(L);
            break;
        }
        case 2:{
            int m;
            cout<<"请输入你要删除的位置：";
            cin>>m;
            DeleteSqList(L,m);
            ShowSqList(L);
            break;
        }
        case 3:{
            int m,n;
            cout<<"请输入你要修改的位置：";
            cin>>m;
            cout<<"请输入你要修改的元素：";
            cin>>n;
            UpdateSqList(L,m,n);
            ShowSqList(L);
            break;
        }
        case 4:{
            SqList Lb;
            InitSqList(Lb);
            cout<<"请创建你要合并的顺序表Lb："<<endl;
            int n;
            cout<<"请输入Lb的元素个数：";
            cin>>n;
            cout<<"你所输入的"<<n<<"个元素分别为：";
            for(int i=0;i<n;i++){
                cin>>Lb.elem[i];
                Lb.length++;
            }
            CombineSqList(L,Lb);
            cout<<"合并后：";
            ShowSqList(L);
            break;
        }
        case 5:{
            SqList Lb,Lc;
            InitSqList(Lb);
            InitSqList(Lc);
            cout<<"请创建你要合并的顺序表Lb："<<endl;
            int n;
            cout<<"请输入Lb的元素个数：";
            cin>>n;
            cout<<"你所输入的"<<n<<"个元素分别为：";
            for(int i=0;i<n;i++){
                cin>>Lb.elem[i];
                Lb.length++;
            }
            CombineSq(L,Lb,Lc);
            cout<<"合并后：";
            ShowSqList(Lc);
            break;
        }
    }
    return 0;
}