[算法] 链表

链表的实现

一、静态链表

#include<stdio.h>
struct node{
    int data;
    struct node *next;
};
typedef struct node NODETYPE;

int main(){
    NODETYPE a,b,c,*h,*p;
    a.data=10;b.data=20;c.data=30;
    h=&a;
    a.next=&b;b.next=&c;c.next='';
    p=h;
    while(p){
        printf("%d",p->data);
        p=p->next;
    }
    printf("
");
}

分析：

1、此程序仅示意原理，在执行过程中不能人为再产生新的存储单元，也不能使已开辟的单元消失

2、在实际中多采用动态链表

二、动态链表

#include<stdio.h>
#include<stdlib.h>

struct slist{
    int data;
    struct slist *next;
};
typedef struct slist SLIST;

SLIST *creat_slist(){
    int c;
    SLIST *h,*s,*r;
    h=(SLIST*)malloc(sizeof(SLIST));
    r=h;
    scanf("%d",&c);
    while(c!=-1){
        s=(SLIST*)malloc(sizeof(SLIST));
        s->data=c;
        r->next=s;
        r=s;
        scanf("%d",&c);
    }
    r->next='';
    return h;
}
void print_slist(SLIST *head){
    SLIST *p;
    p=head->next;
    if(p=='') printf("Linklist is null!
");
    else{
        printf("head");
        do{
            printf("-->%d",p->data);
            p=p->next;
        }
        while(p!='');
        printf("-->end
");
    }
}
void insert_snode(SLIST *head,int x,int y){
    SLIST *s,*p,*q;
    s=(SLIST *)malloc(sizeof(SLIST));
    s->data=y;
    q=head;p=head->next;
    while((p!='')&&(p->data!=x)){
        q=p;p=p->next;
    }
    s->next=p;q->next=s;
}
void delete_snode(SLIST *head,int x){
    SLIST *p,*q;
    q=head;p=head->next;
    while((p!='')&&(p->data!=x)){
        q=p;p=p->next;
    }
    q->next=p->next;
    free(p);
}
int main(){
    SLIST *head;
    head=creat_slist();
    print_slist(head);
    insert_snode(head,2,4);
    print_slist(head);
    delete_snode(head,3);
    print_slist(head);
}

分析：

1、创建链表

（1）功能：每次输入一个数并加到链表中

（2）输入输出：无；头结点指针h

（2）临时变量：头结点h，尾结点r，新结点s

2、输出链表

（1）功能：打印所有结点

（2）输入输出：头结点指针；head-->1-->2-->end（示例）

（3）临时变量：头结点p

3、插入结点

（1）功能：在某结点前插入新结点

（2）输入输出：头结点指针，插入结点的数据x，插入数据y；无

（3）临时变量：新结点s，前驱q，后继p

4、删除结点

（1）功能：删除某结点

（2）输入输出：头结点指针，删除结点的数据x；无

（3）临时变量：待删除结点p，前驱q

三、复杂动态链表

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

typedef int ElementType;        //定义数据类型,可根据需要进行其他类型定义
//链表节点的定义
typedef struct ListNode {
    ElementType  Element;        //数据域，存放数据
    ListNode* Next;        //指向下一个链表节点
} Node, *PNode;

//链表创建函数定义
PNode CreateList(void) {
    int len ;    //用于定义链表长度
    int val ;    //用于存放节点数值
    PNode PHead = (PNode)malloc(sizeof(Node));    //创建分配一个头节点内存空间
//头节点相当于链表的哨兵，不存放数据，指向首节点（第一个节点）
    if (PHead == NULL) {  //判断是否分配成功
        printf("空间分配失败 
");
        exit(-1);
    }

    PNode PTail = PHead;    //链表的末尾节点，初始指向头节点
    PTail->Next = NULL;    //最后一个节点指针置为空
    printf("请输入节点个数：");
    scanf("%d", &len);        //输入节点个数
    for (int i = 0; i < len; i++) {

        PNode pNew = (PNode)malloc(sizeof(Node));    //分配一个新节点
        if (pNew == NULL) {
            printf("分配新节点失败
");
            exit(-1);
        }
        printf("请输入第 %d 个节点的数据：", i + 1);
        scanf("%d", &val);    //输入链表节点的数据

        pNew->Element = val;    //把数据赋值给节点数据域
        PTail->Next = pNew;    //末尾节点指针指向下一个新节点
        pNew->Next = NULL;        //新节点指针指向为空
        PTail = pNew;    //将新节点复制给末尾节点
    }
    printf("创建链表成功
");
    return PHead;    //返回头节点
}

void TraverseList(PNode List) {
    PNode P = List->Next;
    printf("遍历链表的值为：");
    if(P==NULL) printf("链表为空");
    while(P!=NULL) {
        printf("%d",P->Element);
        P=P->Next;
    }
    printf("
");
}

PNode FindList(PNode List) {
    PNode P = List->Next;
    int num = 0;
    int val = 0;
    printf("请输入要查询的数：");
    scanf("%d",&val);
    while(P!=NULL && P->Element!=val) {
        P=P->Next;
        ++num;
    }
    if(P!=NULL) printf("找到的节点为：%d",num+1);
    else printf("找不到该节点");
    printf("
");
    return P;
}

void InsertList(PNode List, int pos, int val) {
    int position = 0;
    PNode P = List;
    while(P!=NULL && position<pos-1) {
        P = P->Next;
        ++position;
    }
    PNode Tmp = (PNode)malloc(sizeof(Node));
    if(Tmp == NULL) {
        printf("内存分配失败！");
        exit(-1);
    }
    Tmp->Element = val;
    Tmp->Next = P->Next;
    P->Next = Tmp;
}
//删除整个链表
void DeleteTheList(PNode List) {
    PNode P,Tmp;
    P = List->Next;
    List->Next = NULL;
    while(P!=NULL) {
        Tmp = P->Next;
        free(P);
        P = Tmp;
    }
    printf("删除链表成功！
");
}
//删除链表中的元素
void DeleteList(PNode List,int pos) {
    int position = 0;
    PNode P = List;
    while(P!=NULL && position<pos-1) {
        P = P->Next;
        ++position;
    }
    PNode Tmp = P->Next;
    P->Next = Tmp->Next;
    free(Tmp);
    Tmp=NULL;
}
//主函数
int main() {
    PNode List = CreateList();    //创建一个指针，使其指向新创建的链表的头指针
    TraverseList(List);
    FindList(List);
    InsertList(List,3,100);
    TraverseList(List);
    DeleteList(List,3);
    TraverseList(List);
    DeleteTheList(List);
    TraverseList(List);
    return 0;
}

系统为所有指针均分配4个字节的空间，然后通过不同类型的寻址方式得到变量：

https://blog.csdn.net/boy_of_god/article/details/80868727