线性表与单链表操作：反转、查找、插入与删除-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_36738861/article/details/122152496

算法空间复杂度分析例题

将一个数组中的元素逆序存放在元数组中

数组：

$input  = array("php", 4.0, array("green", "red"));

算法一：原地工作，空间复杂度为s(n)=O(1)

$input  = array("php", 4.0, array("green", "red"));
function array_reverse_v1(array $data):array{
    $len=count($data);
    for ($i=0;$i<$len/2;$i++){
        $t=$data[$i];
        $data[$i]=$data[$len-$i-1];
        $data[$len-$i-1]=$t;
    }
    return $data;
}
print_r(array_reverse_v1($input));

输出：

Array
(
    [0] => Array
        (
            [0] => green
            [1] => red
        )

    [1] => 4
    [2] => php
)

算法二：空间复杂度为s(n)=O(n)

function array_reverse_v2(array $data):array{
    $len=count($data);
    $tmp=[];
    for ($i=0;$i<$len;$i++){
        $tmp[$i]=$data[$len-$i-1];
    }
    for ($i=0;$i<$len;$i++){
        $data[$i]=$tmp[$i];
    }
    return $data;
}
print_r(array_reverse_v2($input))

输出：

Array
(
    [0] => Array
        (
            [0] => green
            [1] => red
        )

    [1] => 4
    [2] => php
)

php函数

$result= array_reverse($input);
print_r($result);

输出：

Array
(
    [0] => Array
        (
            [0] => green
            [1] => red
        )

    [1] => 4
    [2] => php
)

回顾
在这里插入图片描述

线性表

线性表的定义和特点

定义：线性表是具有相同特性的数据元素的一个有限序列

(a1,a2,…ai-1,ai,ai+1,…an)

数据元素：a1到an称为数据元素

线性起点线性终点：a1为线性的起点，an为线性的终点，也叫终端节点；中间的任意一个元素叫做数据元素或者也叫做节点

前驱和后继：其中任意一个元素如ai，他的前一个元素称为ai的直接前驱(ai-1),后一个元素称为ai的直接后继

下标：是元素的序号，表示元素在表中的位置；如a2，2就表示在这个线性表的第二个位置

空表：没有元素；n=0时称为空表

表长：n元素的总个数

特点：由n(n>=0)个数据元素(节点)a1,a2,…组成的有序序列
线性表的例子：

分析26个英文字母组成的英文表
星座
学生情况登记表
…

同一线性表中的元素必定具有相同特性，数据元素之间的关系是线性关系

线性表的逻辑特征：

在非空的线性表中，有且仅有一个开始节点a1，它没有直接前驱，而仅有一个直接后继a2;
有且只有一个终端节点an，它没有直接后继，而仅有一个直接前驱an-1;
其余的内部节点ai(2<=i<=n-1)都只有一个直接前驱ai-1，和一个直接后驱ai+1.

案例引入

案例1：一元多项式的运算：实现两个多项式的加减乘除运算
Pn(X)=p0+p1^2+p2x^2+…pnx^n

单链表的基本操作

结构类型定义

typedef struct Lnode{
    ElemType data;
    struct Lnode *next;
}Lnode,*LinkList;

# 变量定义：
LinkList  l;
Lnode *p,*s;

单链表的初始化操作(带头节点的单链表)
算法步骤：

生成新节点做为头节点，用头指针L指向头节点。
将头节点的指针域置空

Status InitList_L(LinkList &L){
    L=new LNode;//或L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    return OK;
}

判断链表是否为空
算法步骤：
空表：链表中无元素，称为空链表(头指针和头节点任然在)
算法思路：
判断头节点指针域是否为空

int ListEmpty(LinkList L){
    if(L->next)
    return 0;
    else 
    return1;
}

单链表的销毁：链表销毁后不存在
算法思路：从头指针开始以此释放所有节点

Status DestroyList_L(LinkList &L){
    Lnode *p;//或者LinkList p;
    while(L){
        p=L;
        L=L->next;
        delete p;
    }
    return ok;
}

单链表清空操作，但链表中无元素，成为空链表(头指针头节点任然存在)
算法思路：依次释放所有节点，并将头节点指针域设置为空

Status  clearList(LinkList &L){
    Lnode *p,*q;//或者Linklist p,q; p代表当前节点，q代表下一节点
    p=L->next;
    while(p){
       q=p->next;
       delete p;
       p=q;
    }
    L->next=null; //头结点指针域置空
    return ok;
}

单链表：求表长
算法思路：从首元节点开始，依次计数所有节点

int ListLength_L(LinkList L){
    LinkList p;
    p=L->next;
    i=0;
    while(p){
        i++;
        p=p->next;
    }
    return i;
}

单链表：取单链表中第i个元素的内容
思考：顺序表里如何找到第i个元素？ L->elem[i-1]
从链表的头指针出发，顺着链域next逐个节点往下搜索，直到搜到第i节点为止。因此，链表不是随机存取结构

//获取线性表L中的某个元素的内容，通过变量e返回
Status GetElm_L(LinkList L,int i,ElemType &e){
     p=L->next;j=1;//初始化
     while(p&&j<i){ //向后扫描，直到P指向第i个元素或p为空
        p=p->next;j++;
     }
     if(!p||j>i) return ERROR;
     e=p->data;
     return ok;
}

单链表的查找

按值查找：根据指定数据获取数据所在位置(该数据的地址)

Lnode *LocateElem_L (LinkList L ,Elemtype e){
    p=L->next;
    while(p && p->data!=e){
        p=p->next;
    }
    return p;
}

按值查找：根据指定数据获取数据所在位置序号(是第几个数据元素)

int LocateElem_L(LinkList L,Elemtype e){
    p=L->next; j=1;
    while(p && p->data!=e){
        p=p->next;j++;
    }
    if(p) return j;
    else return 0;
}

单链表：插入操作；在第i个节点前插入值为e的新节点

Status ListInsert_L(LinkList &L ,int i ElemType e){
    p=L;j=0;
    while(p && j<i-1){p=p->next;j++}//寻找第i-1个节点，p指向i-1节点
    if(!p || j>i-1) return ERROR;//大于表长+1或者小于1，插入位置非法
    s=new Lnode;s->data=e;//生成新节点s,将节点s的数据域置为e
    s->next=p->next;//将节点插入L中
    p->next=s;
}

单链表：删除第i个节点
算法步骤:

首先找到ai-1的存储位置p;保存要删除的ai的值
令p->next指向ai+1
释放掉节点ai的空间

Status ListDelete_L (LinkList & L,int i ,Elemtype &e){
        p=L;j=0;
        Lnode q;
        while(p && j<i-1){p=p->next;++j}//寻找第i个节点，命令p指向其前驱
        if(!(p->data) || j>i-1) return ERROR;//删除位置不合理
        q=p->next;//临时保存删除节点，以备释放
        p->next=q->next;//改变删除节点的前驱节点的指针域
        e=q->data; //保存删除节点的数据域
        delete q;//释放节点的空间
        return OK;
}//ListDelete_L

单链表：查找、插入、删除的时间效率

查找：

因线性表只能顺序存取，即在查找时要从头指针找起，查找的时间复杂度为O(n)

插入和删除：

因线性表不需要移动元素，只需要修改指针，一般情况下时间复杂度为O(1)
但是：如果要在单链表中进行前插和删除操作，由于要从头查找前驱的节点，所消耗时间复杂度为O(n)

单链表建立：头插法，也叫前插
时间复杂度O(n)

void CreateList_H(LinkList &L,int n){
    L=new LNode;
    L->next=NULL;//先建立一个带头节点的单链表
    for(i=n;i>0;--i){
        p=new LNode;//生成新节点p=(LNode*)malloc(sizeof(lNode));
        cin>>p->data;
        p->next=L->next;//插入到表头
        L->next=p;
    }
}//CreateList_H

单链表建立：尾插法
时间复杂度O(n)

void CreateList_R(LinkList &L,int n){
    L=new LNode;
    L->next=NULL;//先建立一个带头节点的单链表
    r=L;//尾指针r指向头节点
    for(i=0;i<n;++i){
        p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;//插入到尾表
        r=p;//r指向新的尾节点
    }
}//CreateList_H