数据结构整理——第二章 线性表

考研时个人整理的，参考王道、严蔚敏等数据结构。

上一章——序言： https://blog.csdn.net/mooe1011/article/details/87894843

下一章——栈和队列：https://blog.csdn.net/mooe1011/article/details/88089325

 

线性表

• 串是一种特殊的线性表, 其特殊性体现在数据元素是一个字符

1.顺序表

1. 可随机访问，在尾部插入删除时间为O(1)，其他位置则要移动元素
2. 存储密度高，结点是数据元素
3. 逻辑顺序与物理顺序一样
4. 也可存储非线性结构，如满二叉树的顺序存储
5. 插入一点所移动平均次数为n/2；删除为(n-1)/2；查找为(n+1)/2
6. 注意事项：
   1. 如果下标从0开始，则最后一个元素为L.data[L.length-1],返回元素位置记得要i+1
   2. 如果函数接口如果有引用顺序表，SqList &L，记得修改L.length

#define MaxSize 50
typedef struct{
    int data[MaxSize];
    int length;
}SqList;

• 检查越界 L.length==0||i>L.length
• 插入 bool ListInsert
  • 最好O(1)；平均O(n);要检查L.length>=MaxSize
  • 判断合法，注意length+1

if(i<1||i>L.length+1||L.length>=MaxSize)  //下标从1开始
    return false;

//从最后一个开始移动，注意length

for (int j=L.length;j>=i;j--)
    L.data[j]=L.data[j-1];
L.data[i-1]=e;
L.length++;
return true;

• 删除

bool ListDelete(SqList &L;int i,int &e){
    if (i<1 ||i>L.length)
        return false;
    e=L.data[i-1];
    for(int j=i;j<L.length;j++)
        L.data[j-1]=L.data[j];
    L.length--;
    return
}

• 删除k个元素

if (L.data[i]要删除) k++;
else L.data[i-k]=L.data[i];
L.length -=k；

• 不删除k个元素（上面改进）

if (L.data[i]不用删除) L.data[k++]=L.data[i];
L.length =k;

• 合并 Merge

检查C.MaxSize小于A、B长度和
while(i<A.length&&j<B.length)
    C.data[k++]=A.data[i]<=B.data[j] ? A.data[i++] : B.data[j++];
while(i<A.length)
    C.data[k++]= A.data[i++];
while(j<B.length)
    C.data[k++]= B.data[j++];
C.length=k;

• 折半查找 Binary Search

int low=0,high=L.length-1,mid;
while(low<=high) {
    mid=(low+high)/2;
    if(找到)break;
    else if(在右半) low=mid+1;
    else high=mid-1;
}

• 数组ab逆转为ba

void Reverse(int R[],int from,int to){
    int i,temp;
    for(i=0;i<(to-from)/2;i++){
        temp=R[from+i];
        R[from+i]=R[to-i];
        R[to-i]=temp;
    }
}
void Converse(...){
    Reverse(R,0,p-1);
    Reverse(R,p,n-1);
    Reverse(R,0,n-1);
}

2.链表

1. 尾插法记得尾节点指针置空 r->next=NULL;
2. 双链表插入删除复杂度都为O(1)；建立有序单链表的最低时间复杂度为O(nlog2N)
3. 循环单链表判空条件为头结点指针等于自身；任何位置插入删除操作无须判断是否表尾
4. 静态链表的指针是指示下一个元素在数组中的下标，又称游标

• 循环列表的优点从任意节点出发都能访问到整个链表
• 创建头结点 L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;
• 遍历 1.指向第一个 LNode *p=L->next；2.p=p->next;
• 递归 del_x(L->next,x);

typedef struct DNode{
    int data;
    struct DNode *prior,*next;
}DNode,*Dlinklist;

• 递归删除值为x的结点

void del_x (Linklist &L,int x) {
    LNode *p;
    if(L==NULL) return;
    if(L->data==x){
        p=L;
        L=L->next;
        free(p);
        del_x(L,x);
    }
    else del_x(L->next,x);
}

• 删除带头结点单链表值为x的结点

1. 使用pre指向前驱结点

LNode *p=L->next,*pre=L,*q;
while(p!=NULL){
    if(p->data==x){
        q=p;
        p=p->next;
        pre->next=p;
        free(q);
    } else {
        pre=p;
        p=p->next;
    }
}

另：也可使用p代替pre,p->next代替p
LNode *p=L,*q;  //头结点
while(p->next!=NULL）{
    if(p->next->data==x){
        q=p->next;
        p->next=p->next->next;
        free(q);
    } else p=p->next;
}

1. 尾插法 记得 r->next=NULL

LNode *p=L->next,*r=L,*q;  //r指向尾节点
while(p!=NULL){
    if(p->data!==x){
        r->next=p;
        r=p;
        p=p->next;
    } else {
        q=p;
        p=p->next;
        free(q);
    }
}
r->next=NULL;

• 递归逆转

void R(LinkList L){
    if(L->next!=NULL)
        R(L->next);
    print(L->data);
}

• 逆转

LNode *p,*r;
p=L->next;
L->next=NULL;
whlie(p!=NULL){
    r=p->next;
    p->next=L->next;
    L->next=p;
    p=r;
}