1.顺序表基本操作

Posted 2020-10-06 在凌晨

（ps上了大学，一开始不知道自己专业是学编程的，等到半路知道自己是学编程的时候，又不知道到底该怎么学，该学什么。一直处于一个很尴尬的境地。

大一的时候玩了玩pangolin，学了html和一点点java就想搞sql注入。想想当时挺好玩的，也算是步入了编程这条不归路吧。

到了大二开始学java，当时很懵逼为什么jdk要配置环境变量，环境变量又什么鬼，eclipse又是啥，myeclipse又TM是啥...

到了大三，学完了框架，ssh没怎么写，主要用ssm写了几个项目，感觉就是增删改查，顶多加个solr搞个搜索啥的，然后到了春招，开始后悔当初数据结构没好好学 ，就记得有一道后缀表达式的题都不知道怎么算，自己想想，是真的菜。

大四了，想想自己二本的学校，还想往上海跑，考研，也是迫不得已啊，毕竟这些大佬公司我连笔试都过不了）

数据结构主要是根据王道上面的题来写的，可能自己会加一些比较经典的习题，废话不多说，开始吧。

线性表

  学线性表，线性表按存储类型划分，则有顺序存储和链式存储两种，顺序存储即顺序表，链式存储包括单链表、双链表、循环链表以及静态链表，因为408现在要求只能用c或c++语言进行答题，因此前三种使用c++是以指针方式实现，静态链表借助数组实现。

  从顺序表开始，把它每个的基本操作都用c或c++语言实现出来，这样能够增加自己的记忆，也方便理解，在细节上也不会出错，例如数组下标的问题等等。

1.顺序表的定义

 在定义顺序表时，需要注意线性表中元素的位序是从1开始的，而数组中的元素的下标是从0开始的。

 

#define Maxsize 50    //定义线性表的最大长度
typedef  struct{
    int data[Maxsize];//顺序表的元素
    int length;       //顺序表当前长度
}SqList;              //顺序表的类型定义

 

 

 

 

 

2.插入元素

在顺序表L的第i（L<=i<=L.length+1）个位置插入新元素e，时间复杂度为O（n）实现代码如下

 

/*
 *插入操作
 */
bool ListInsert(SqList &L,int i,int e){
    if(i<1||i>L.length+1)    //判断i的范围是否有效
        return false;
    if(L.length>=Maxsize)    //当前存储空间已满，不能插入
        return false;
    for(int j=L.length;j>=i;j--)    //将第i个元素及之后的元素后移
        L.data[j]=L.data[j-1];
  
    L.data[i-1]=e;                //在位置i处放入e
    L.length++;                  //线性表长度加1
    return true;
}

 

 

 

 

3.删除第i个位置的元素，平均时间复杂度为O（n）

/*
 *删除操作
 */
bool ListDelete(SqList &L,int i, int &e){
    if(i>L.length+1||i<1)      //判断i的范围是否有效
        return false;
    e = L.data[i-1];           //将被删除的元素赋给e
    for (int j=i; j<L.length; j++)//将第i 个位置之后的元素前移
        L.data[j-1]=L.data[j];
    L.length--;                //线性表长度减1
    return true;
}

 

 

 

4.按值查找

按值查找的时间复杂度为 O（n）

 

/*
 *按值查找
 */
int LocateElem(SqList L,int  e){
    int i;
    for(i = 0; i < L.length; i++)
        if(L.data[i]==e){
            return i+1;     //下标为i的元素值等于e，返回位序i+1
        }
    return 0;
}

 总的代码

//
//  main.cpp
//  ArrayList
//
//  Created by zhuzhengjun on 2017/9/5.
//  Copyright ? 2017年 zhuzhengjun. All rights reserved.
//

#include <iostream>
#include "stdio.h"
using namespace std;
#define Maxsize 50    //定义线性表的最大长度
typedef  struct{
    int data[Maxsize];//顺序表的元素
    int length;       //顺序表当前长度
}SqList;              //顺序表的类型定义

/*
 *插入操作
 */
bool ListInsert(SqList &L,int i,int e){
    if(i<1||i>L.length+1)    //判断i的范围是否有效
        return false;
    if(L.length>=Maxsize)    //当前存储空间已满，不能插入
        return false;
    cout <<"L.length";
    cout << L.length <<endl;
    cout << "L.data[L.length]";
    cout << L.data[L.length-2] <<endl;
    for(int j=L.length;j>=i;j--)    //将第i个元素及之后的元素后移
        L.data[j]=L.data[j-1];
  
    L.data[i-1]=e;                //在位置i处放入e
    L.length++;                  //线性表长度加1
    for (int i=0; i<L.length; i++) {
        cout << "Insert";
        cout <<L.data[i] <<endl;
    }
    return true;
}


/*
 *删除操作
 */
bool ListDelete(SqList &L,int i, int &e){
    if(i>L.length+1||i<1)      //判断i的范围是否有效
        return false;
    e = L.data[i-1];           //将被删除的元素赋给e
    for (int j=i; j<L.length; j++)//将第i 个位置之后的元素前移
        L.data[j-1]=L.data[j];
    L.length--;                //线性表长度减1
    for (int i=0; i<L.length-1; i++) {
        cout << "Delete" ;
        cout << L.data[i]<<endl;
    }
    return true;
}


/*
 *按值查找
 */
int LocateElem(SqList L,int  e){
    int i;
    for(i = 0; i < L.length; i++)
        if(L.data[i]==e){
            return i+1;
        }
    return 0;
}

int main(int argc, const char * argv[]) {
    // insert code here...
    SqList slist;
    slist.length=49;
    for (int i=0; i<slist.length-1; i++) {
        slist.data[i]=i;
    }
//    for (int i=0; i<50; i++) {
//        cout << slist.data[i]<<endl;
////    }
    int e=24;
    bool s = ListInsert(slist,24,24);
    bool d = ListDelete(slist,24,e);
    cout << "顺序表插入情况";
    cout << s <<endl;
    cout << "顺序表删除情况";
    cout << d <<endl;
    cout << "23所在的位置";
    cout <<LocateElem(slist, 23)<<endl;
    
    printf("hello\n");
    cout << "Hello, World!\n"<<endl;
    return 0;
}

 

优点：顺序表由于是随机存取，因此存储密度大，输出指定的元素值以及交换元素值都比链表效率高，在插入的时候注意表尾可以追加元素。 

缺点：顺序表逻辑上相邻的元素物理上也相邻，所以插入和删除操作需要移动大量元素，效率不高。