数据结构（3）-----链表

一、线性结构：
　　数组：
　　(1) 一片连续的内存空间 不能是断开的
　　(2) 因为是连续的内存空间 才可以使用下标来访问
　　　　arr[i] === *(arr+i)
　　　　访问效率非常高
　　(3) 在数据前面插入和删除的效率都比较低 (需要移动数据)

　　链表：
　　(1) 内存是不连续的
　　(2) 访问效率比较低 因为需要从第一个元素开始遍历
　　(3) 在任何地方插入和删除的效率都比较高 (只需要改变指针的值)

二、单向链表

　　单向链表的节点：节点元素+下一个节点的地址

typedef int T;
//单向链表的节点
typedef struct SNode{
    T data;             //节点元素
    struct SNode *next; //下一个节点的地址   指向下一个节点
}SNode;

//定义单向链表类型 SLink
typedef struct SNode *  SLink;

　　1.初始化链表 

　　　　申请头节点的动态内存 头节点不保存数据 也没有下一个节点的地址（NULL）

void init(SLink* plink){
    *plink = malloc(sizeof(SNode));    
    (*plink)->next = NULL;
}
SLink createSLink(){
    SNode * node = malloc(sizeof(SNode));
    node->next = NULL;
    return node;
}

　　2.判断链表是否为空

bool isEmpty(SLink link){
    return link->next == NULL;    
}

　　3.在头部插入一个节点 将要存储的数据加入

void insertFront(SLink link,T data){
    SNode *node = malloc(sizeof(SNode));
    node->data = data;
    node->next = link->next;
    link->next = node;
}

　　4.遍历链表

void travel(SLink link){
    if(link != NULL){
        SNode *node = link->next;
        while(node != NULL){
            printf("%d ",node->data);
            node = node->next;
        }
        printf("
");
    }
}

　　5.链表数据个数

size_t size(SLink link){
    SNode *node = link->next;    
    size_t cnt = 0;
    while(node != NULL){
        cnt++;
        node = node->next;
    }
    return cnt;
}

　　6.获得index下标位置节点的前一个节点

static SNode *getPrevNode(SLink link,size_t index){
    SNode *node = link;
    for(int i=0;i<index;i++){
        node = node->next;    
    }
    return node;
}

　　7.在指定的下标位置插入一个元素

void insert(SLink link,size_t index,T data){
    if(index>size(link)){
        return;
    }
    //找到index下标节点的前一个节点
    SNode *prevNode = getPrevNode(link,index);
    SNode *currNode = malloc(sizeof(SNode));
    currNode->data = data;
    currNode->next = prevNode->next;
    prevNode->next = currNode;
}

　　8.根据下标删除元素

void deleteByIndex(SLink link,size_t index){
    if(index>=size(link)){
        return;    
    }    
    SNode *prevNode = getPrevNode(link,index);
    SNode *currNode = prevNode->next;
    prevNode->next = prevNode->next->next;
    free(currNode);//释放内存
}

　　9.清空链表中的元素

void clear(SLink link){
    SNode *node = link->next;
    while(node != NULL){
        SNode *next = node->next;//记录当前节点的后一个节点位置
        free(node);//释放当前节点的内存
        node = next;//指向下一个节点
    }
    link->next = NULL;
}

　　10.销毁链表

void destroy(SLink *plink){
    clear(*plink);
    free(*plink);
    *plink = NULL;
}

　　11.删除链表中第一个数据是data的节点

void deleteData(SLink link,T data){
    SNode *prevNode = link;
    SNode *currNode = link->next;
    while(currNode != NULL){
        if(currNode->data == data){
            prevNode->next = currNode->next;
            free(currNode);
            return;
        }    
        prevNode = currNode;
        currNode = currNode->next;
    }
}

　　12.删除链表中所有数据是data的节点

void deleteAllDatas(SLink link,T data){
    SNode *prevNode = link;//头节点
    SNode *currNode = link->next;
    while(currNode != NULL){
        if(currNode->data == data){
            prevNode->next = currNode->next;
            free(currNode);
            currNode = prevNode->next;
            continue;
        }    
        prevNode = currNode;
        currNode = currNode->next;
    }
}

　　13.根据下标修改链表中的元素

void modify(SLink link,size_t index,T data){
    if(index>=size(link)){
        return;
    }    
    SNode *node = getPrevNode(link,index+1);
    node->data = data;
}

　　14.根据下标获取元素

　　　　如果index>=size(link)都将引发错误

T getDataByIndex(SLink link,size_t index){
    /*
    if(index>=size(link)){
        return -1;    
    }
    */
    SNode *node = link->next;
    for(int i=0;i<index;i++){
        node = node->next;    
    }
    return node->data;
}

　　15.链表逆序  ---笔试题概率最大的编程题

void reverse(SLink link){
    //if(link==NULL){return;}
    //没有节点或者只有一个节点时 不需要做任何事情
    if(link->next == NULL || link->next->next == NULL){
        return;    
    }
    SNode *prevNode = link->next;//第一个节点  前面节点
    SNode *currNode = prevNode->next;//第二个节点
    while(currNode != NULL){
        SNode *nextNode = currNode->next;//记录当前节点的后一个节点
        currNode->next = prevNode;//让当前节点的next指向之前的前节点
        prevNode = currNode;//前节点变 指向现在当前的节点
        currNode = nextNode;//当前的节点 指向 下一个节点
    }
    link->next->next = NULL;//让原来的第一个节点的next指向NULL
    link->next = prevNode;//让头节点next指向原来最后的那个节点
}

三、双向链表

typedef int T;

typedef struct DNode{
    T data;
    struct DNode *prev;
    struct DNode *next;
}DNode;

typedef struct DLink{
    //头尾结点不存储数据
    DNode *head;//指向头节点
    DNode *tail;//指向尾节点
}DLink;

　　1.初始化链表

　　申请头节点和尾节点的动态内存 

　　双向链表的头节点prev指向NULL next指向尾节点  尾节点prev指向头节点 next指向NULL

void init(DLink *dlink){
    dlink->head = malloc(sizeof(DNode));
    dlink->tail = malloc(sizeof(DNode));
    dlink->head->prev = NULL;
    dlink->head->next = dlink->tail;
    dlink->tail->prev = dlink->head;
    dlink->tail->next = NULL;
}

　　2.清空链表所有节点

void clear(DLink *dlink){
    DNode *node = dlink->head->next;
    while(node != dlink->tail){
        DNode *next = node->next;
        free(node);
        node = next;
    }
    dlink->head->next = dlink->tail;
    dlink->tail->prev = dlink->head;
}

　　3.销毁链表

oid destroy(DLink *dlink){
    clear(dlink);
    free(dlink->head);
    dlink->head = NULL;
    free(dlink->tail);
    dlink->tail = NULL;
}

　　4.链表是否为空

bool isEmpty(DLink dlink){    
    return dlink.head->next == dlink.tail && dlink.head == dlink.tail->prev;
}

　　5.链表元素个数

size_t size(DLink dlink){
    DNode *node = dlink.head->next;
    size_t cnt = 0;
    while(node != dlink.tail){
        cnt++;
        node = node->next;
    }
    return cnt;
}

　　6.从头部插入一个元素

　　需要创建新的节点，申请新的动态内存

　　头节点的prev还是指向NULL，next指向新节点
　　尾节点的next还是指向NULL，prev指向新节点
　　新节点的next指向尾节点，prev指向头节点

void insertFront(DLink dlink,T data){
    DNode *node = malloc(sizeof(DNode));
    node->data = data;
    node->next = dlink.head->next;
    node->prev = dlink.head;
    dlink.head->next->prev = node;
    dlink.head->next = node;
}

　　7.获得上一个节点

static DNode * getPrevNode(DLink dlink,size_t index){
    DNode *node = dlink.head;
    for(int i=0;i<index;i++){
        node = node->next;    
    }
    return node;
}

　　8.根据下标插入一个元素

void insert(DLink dlink,size_t index,T data){
    if(index > size(dlink)){
        return;    
    }
    DNode *prevNode = getPrevNode(dlink,index);
    DNode *node = malloc(sizeof(DNode));
    node->data = data;
    node->next = prevNode->next;
    node->prev = prevNode;
    prevNode->next->prev = node;
    prevNode->next = node;
    
}

　　9.根据下标删除一个元素

void deleteByIndex(DLink dlink,size_t index){
    if(index >= size(dlink)){
        return;    
    }
    DNode *currNode = getPrevNode(dlink,index+1);
    currNode->next->prev = currNode->prev;
    currNode->prev->next = currNode->next;
    free(currNode);
}

　　10.从头部开始遍历链表

void travelFront(DLink dlink){
    DNode *node = dlink.head->next;
    while(node != dlink.tail){
        printf("%d ",node->data);    
        node = node->next;
    }
    printf("
");
}

　　11.从尾部开始遍历链表

void travelBack(DLink dlink){
    DNode *node = dlink.tail->prev;
    while(node != dlink.head){
        printf("%d ",node->data);
        node = node->prev;
    }
    printf("
");
}