数据结构复习——链表（一）

一.顺序存储

插入删除操作：

        *p_n是len吧相当于，依次赋值的时候从最后往最前面赋值，插入与删除操作平均时间复杂度为O(n)。

优点：

        实现了随机存取，快速访问线性表中任何一个元素。

缺点：

        插入或删除一个结点的效率比较低，而且不容易扩充数量。

int sq_insert(int list[],int *p,int i,int x){
    for(int j = *p;j>i;j--){
        list[j] = list[j-1];
    }
    list[i] = x;
    (*p)++;
    return 0;
}
int sq_delete(int list[],int i,int *p){
    for(int j = i+1;j<*p;j++){
        list[j-1] = list[j];
    }
    *p--;
    return 0;
}

二 链接存储

每个结点 = 数据域+指针域 根据指针的不同，分为各种链表

下面为含有表头结点的链表，优点：

（1）便于首元结点的处理

（2）便于空表和非空表的统一处理

顺序存取

有无头节点的头插和尾插操作

typedef struct node
{
    int val;
    struct node*next;
    /* data */
}NODE;
//无表头结点的头插法
NODE* creat_list_NH(int n){
    if(n == 0) return NULL;

    NODE *head,*p;
    head = NULL;
    for(int i =0;i<n;i++){
        p = (NODE*)malloc(sizeof(NODE));
        scanf("%d",&p->val);
        p->next = head;
        head = p;
    }
    return head;
}

NODE *creat_list_NR(int n){
    if(n == 0) return NULL;
    NODE*head,*p,*work;
    p = (NODE*)malloc(sizeof(NODE));
    p->next = NULL;
    head = p;
    scanf("%d",&p->val);
    work = p;

    for(int i = 1;i < n;i++){
        p = (NODE*)malloc(sizeof(NODE));
        scanf("%d",&p->val);
        p->next = NULL;
        work->next = p;
        work = p;
    }
    return head;
}
//有头节点
NODE *initial(){
    NODE *head;
    head = (NODE*)malloc(sizeof(NODE));
    head->next = NULL;
    return head;
}

NODE *creat_list_H(int n){
    NODE *head = initial();
    NODE *p;
    for(int i = 0;i<n;i++){
        p = (NODE*)malloc(sizeof(NODE));
        scanf("%d",&p->val);
        p->next = head->next;
        head->next = p;
    }
    return head;
}

NODE *creat_list_R(int n){
    NODE *head = initial();
    NODE*r,*p;
    if(n ==0) return NULL;
    r = head;
    for(int i = 0;i <n;i++){
        p = (NODE*)malloc(sizeof(NODE));
        scanf("%d",&p->val);
        p->next = NULL;
        r->next = p;
        r = p;
    }
    return head;
}

删除操作

//不带表头结点
int delete(NODE *head,int val){
    NODE *q,*p;
    q = head;
    if(q == NULL) return -1;
    if(q->val == val){
        head = q->next;
        free(q);
        return 0;
    }
    //p相当于存放q的前一个结点
    while(q->val != val && q->next != NULL){
        p = q;
        q = q->next;
    }
    if(q->val == val){
        p->next = q->next;
        free(q);
        return 0;
    }
    else return 1;
}

 环形链表

 双向环形链表的插入删除操作

//双向环形链表
typedef struct data1
{
    int val;
    struct data1* prior;
    struct data1* next;
    /* data */
}NODE1;

//将y插入到x后面
int insert_d_l(NODE1 *head,int x,int y){
    NODE1*p,*q;
    p = head->next;
    while(p != head && p->val != x){
        p = p->next;
    }
    if(p == head) return 1; //找不到结点x
    q = (NODE1*)malloc(sizeof(NODE1));
    q->val = y;
    p->next->prior = q;
    q->next = p->next;
    p->next = q;
    q->prior = p;
    return 0;
}
int delete(NODE1*head,int x){
    NODE1*p;
    p = head->next;
    while(p != head && p->val != x){
        p = p->next;
    }
    if(p == head) return 1;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    free(p);
    return 0;
}

小结：

三、特殊的链表

假设有n个顺序入栈，只要栈内有元素都可以出栈，则它 们的出栈顺序有几种可能？