链表各种操作的代码实现

链表各种操作的代码实现

定义

首先是链表节点的初始化

第一种写法：

typedef struct ListNode{
	int data; // 数据域
	struct ListNode *next; //指针域
}Node, *ListNode;

第二种写法：

typedef struct ListNode{
	int data;
	struct ListNode *next;
}Node;
typedef struct ListLink{
	int length;
	struct ListNode head;
}Link;

以下都以第二种写法定义为前提

初始化

节点初始化

Node * init_ListNode(int val){
	Node * p = (Node * ) malloc(sizeof(Node));
	p->data = val;
	p->next = NULL;
	return p;
}

链表初始化

Link * init_LinkList(){
    Link * l = (Link *) malloc(sizeof(Link));
    l -> length = 0;
    l-> head = NULL;
    return l;
}

释放空间

释放节点空间

void clear_node(Node *p) {
    if(p == NULL) return;
    free(p);
}

释放链表空间

void clear_node(Link *l) {
    if(l == NULL) return;
    Node *p, *q;
    p = l->head;
    while(p->next != NULL) {
        p = p->next;
        q = p-> next;
        free(p);
        p = q;
    }
}

插入节点

int insert(LInk *l , int ind, int val) {
      if(l == NULL) return 0;
    if(ind < 0 || ind > l->length) return 0;
    Node *node = init_ListNode(val);
    node->data = val;
    Node *p;
    p =&( l->head);
    while(ind--) {
        p = p->next;
    }
    node->next = p->next;
    p->next = node;
    l->length += 1;
    return 1;
}

删除节点

void delete_node(Link *l, int index) {
    if(l == NULL) return;
    if(index < 0 || index >= l->length) return ;
    Node *p, *q;
    p = &(l -> head);
    while(index--) {
        p = p->next;
    } 
    q = p->next;
    p->next = q->next;
    clear_node(q);
    l->length--;
    return ;
}

反转

void reveral(Link *l ) {
       Node *p, *q;
    p = l->head.next;
    while(p) {
        q = p->next;
        p->next = l->head.next;
        l->head.next = p;
         p =q;
    }
    return;
}

总代码

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

typedef struct ListNode {
    int data;
    struct ListNode *next;
}ListNode;

typedef struct List {
    ListNode head;
    int length;
}List;

ListNode *init_ListNode(int val) {
    ListNode *p = (ListNode *)malloc(sizeof(ListNode));
    p->data = val;
    p->next = NULL;
    return p;
}

List *init_List() {
    List *l = (List *)malloc(sizeof(List));
    l->head.next = NULL;
    l->length = 0;
    return l;
}

int insert(List *l, int ind, int val) {
    if (l == NULL) return 0;
    if (ind < 0 || ind > l->length) return 0;
    ListNode *p = &(l->head), *node = init_ListNode(val);
    while (ind--) p = p->next;
    node->next = p->next;
    p->next = node;
    l->length += 1;
    return 1;
}

void clear_node(ListNode *node) {
    if (node == NULL) return ;
    free(node);
    return ;
}

int erase(List *l, int ind) {
    if (l == NULL) return 0;
    if (ind < 0 || ind >= l->length) return 0;
    ListNode *p = &(l->head), *q;
    while (ind--) p = p->next;
    q = p->next;
    p->next = q->next;
    clear_node(q);
    l->length -= 1;
    return 1;
}

void output(List *l) {
    printf("list(%d) = [", l->length);
    for (ListNode *p = l->head.next; p; p = p->next) {
        printf("%d -> ", p->data);
    }
    printf("NULL ]\n");
    return ;
}

void clear_list(List *l) {
    if (l == NULL) return ;
    ListNode *p = l->head.next, *q;
    while (p) {
        q = p->next;
        clear_node(p);
        p = q;
    }
    free(l);
    return ;
}

int main() {
    srand(time(0));
    #define max_op 20
    int op, ind, val;
    List *l = init_List();
    for (int i = 0; i < max_op; i++) {
        op = rand() % 4;
        ind = rand() % (l->length + 3) - 1;
        val = rand() % 100;
        switch (op) {
            case 0:
            case 1:
            case 2: {
                printf("insert %d at %d to List = %d\n",
                       val, ind, insert(l, ind, val));
                output(l);
                printf("\n");
            } break;
            case 3: {
                printf("erase iterm at %d from List = %d\n",
                      ind, erase(l, ind));
                output(l);
                printf("\n");
            } break;
        }
    }
    clear_list(l);
    return 0;
}

.和->的区分

唯一的区别是->前面放的是指针，而.前面跟的是结构体变量，如已定义了一个结构体struct student，里面有一个int a；然后有一个结构体变量struct student stu及结构体变量指针struct student *p；且有p=&stu，那么p->a和stu.a表示同一个意思