链表（C语言）

单向链表

头文件

#include <stdlib.h>包含了malloc函数

结构体声明：

包含数据域和指针域

struct Node
{
    int val;
    struct Node* next;
};

链表初始化及定义一个链表头

拿出头结点 相当于拿到了整个链表

//初始化一个链表

//初始化链表
struct Node* initial()
{
    struct Node* header = malloc(sizeof (struct Node));
    header->val = -1;
    header->next = NULL;
    return header;
}

//定义一个链表头结点

struct Node* header = initial();

链表的结构

链表的基本操作 

链表的遍历 

void Print(struct Node* header)
{
     for (struct Node* pre = header->next; pre != NULL; pre = pre->next)
    {
        printf ("%d ", pre->val);
    }
    printf ("\n");
}

 链表的插入操作

 表示在第 k个插入的数后面插入一个数 x

void insert(struct Node* header, int k, int x)
{
    struct Node* pre = header->next, *pcurrent = pre->next;
    
    for (int i = 1; i < k; i ++ )
    {
        pre = pcurrent;
        pcurrent = pcurrent->next;
    }
     //给要插入的节点赋值
    struct Node* newborn = malloc(sizeof(struct Node));
    newborn->val = x;
    newborn->next = pcurrent;
    pre->next = newborn;
}

头插法

//头插法
void head_insert(struct Node* header, int x)
{
    struct Node* pcurrent = malloc(sizeof(struct Node));
    pcurrent->val = x;
    pcurrent->next = header->next;
    header->next = pcurrent;
}

删除一个数

删除第 k 个插入的数后面的数（当 k 为 0 时，表示删除头结点）

//删除一个节点
void removell(struct Node* header, int k)
{
	
    struct Node* pre = header, *pcurrent = header->next;
  	if (k == 1)
  	{
	  	pre->next = pcurrent->next;
	  	free(pcurrent);
	  	pcurrent = NULL;
	  	return;
  	}
    for (int i = 0; i < k; i ++ )
    {
        pre = pcurrent;
        pcurrent = pcurrent->next;
    }
    
    pre->next = pcurrent->next;
    free(pcurrent);
    pcurrent = NULL;
}

All in：

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

struct Node
{
    int val;
    struct Node* next;
};
//初始化链表
struct Node* initial()
{
    struct Node* header = malloc(sizeof (struct Node));
    header->val = -1;
    header->next = NULL;
    return header;
}
//头插法
void head_insert(struct Node* header, int x)
{
    struct Node* pcurrent = malloc(sizeof(struct Node));
    pcurrent->val = x;
    pcurrent->next = header->next;
    header->next = pcurrent;
}
void insert(struct Node* header, int k, int x)
{
    struct Node* pre = header->next, *pcurrent = pre->next;
    
    for (int i = 1; i < k; i ++ )
    {
        pre = pcurrent;
        pcurrent = pcurrent->next;
    }
     //给要插入的节点赋值
    struct Node* newborn = malloc(sizeof(struct Node));
    newborn->val = x;
    newborn->next = pcurrent;
    pre->next = newborn;
}
//删除一个节点
void removell(struct Node* header, int k)
{
	
    struct Node* pre = header, *pcurrent = header->next;
  	if (k == 1)
  	{
	  	pre->next = pcurrent->next;
	  	free(pcurrent);
	  	pcurrent = NULL;
	  	return;
  	}
    for (int i = 0; i < k; i ++ )
    {
        pre = pcurrent;
        pcurrent = pcurrent->next;
    }
    
    pre->next = pcurrent->next;
    free(pcurrent);
    pcurrent = NULL;
}
void Print(struct Node* header)
{
     for (struct Node* pre = header->next; pre != NULL; pre = pre->next)
    {
        printf ("%d ", pre->val);
    }
    printf ("\n");
}
int main()
{
    int m;
    scanf("%d", &m);
    struct Node* header = initial();
    
    while (m --)
    {
        char op[2];
        scanf("%s", op);
        
        if (op[0] == 'I')
        {
            int k, x;
            scanf("%d%d", &k, &x);
            insert(header, k, x);
            Print(header);
        }
        else if (op[0] == 'H')
        {
            int x;
            scanf("%d", &x);
            head_insert(header, x);
            Print(header);
        }
        else
        {
            int k;
            scanf("%d", &k);
            if(!k) header = header->next;
            else removell(header, k);
            Print(header);
        }
    }
   
}

双向链表

结构体声明

指针域和数据域

struct Node
{
  int val;
  struct Node* l;
  struct Node* r;
};

链表的结构

链表初始化及定义一个链表头

拿到链表头相当于拿到整个链表

struct Node* initial()
{
    struct Node* header = malloc(sizeof (struct Node));
    header->val = -1;
    header->l = NULL;
    header->r = NULL;
    return header;
}

 链表的基本操作

头插法

在链表的头部插入一个结点

即在头结点后面插入一个结点

void head_insert(struct Node* header, int x)
{
	struct Node* newborn = malloc(sizeof(struct Node));
	
	newborn->val = x;
	
	if (header->r != NULL)
	{	 
	     newborn->l = header;
	     newborn->r = header->r;
	     header->r->l = newborn;
	     header->r = newborn;
	}
	else
	{
	    newborn->r = NULL;
	    newborn->l = header;
	    header->r = newborn;
	}
	return;	 
	 
}

尾插法

void Tail_Insert(struct Node* header, int x)
{
	struct Node* pre = header;
    while (pre->r != NULL)
    {
		pre = pre->r;
	}
	struct Node* newborn = malloc(sizeof(struct Node));
	newborn->val = x;
	newborn->l = pre;
	newborn->r = NULL;
	pre->r = newborn;	
}

遍历链表

void Print(struct Node* header)
{
    for (struct Node* pre = header->r; pre != NULL; pre = pre->r)
    {
        printf("%d ", pre->val);
    }
    printf("\n");
}

删除结点

void removell(struct Node* header, int k)
{
    struct Node* pre = header, *pcurrent = pre->r;
    
    for (int i = 0; i < k - 1; i ++ )
    {
        pre = pcurrent;
        pcurrent = pcurrent->r;
    }
    pre->r = pcurrent->r;
    pcurrent->r->l = pre;
    free(pcurrent);
    pcurrent = NULL;
}

All in:

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


struct Node
{
  int val;
  struct Node* l;
  struct Node* r;
};
struct Node* initial()
{
    struct Node* header = malloc(sizeof (struct Node));
    header->val = -1;
    header->l = NULL;
    header->r = NULL;
    return header;
}
void head_insert(struct Node* header, int x)
{
	struct Node* newborn = malloc(sizeof(struct Node));
	
	newborn->val = x;
	
	if (header->r != NULL)
	{	 
	 newborn->l = header;
	 newborn->r = header->r;
	 header->r->l = newborn;
	 header->r = newborn;
	}
	else
	{
	newborn->r = NULL;
	newborn->l = header;
	header->r = newborn;
	}
	return;	 
	 
}
void insert(struct Node* header, int k, int x)
{
	if (k == 0) 
	{
		head_insert(header, x);
		return;
	}
    struct Node* pre = header, *pcurrent = header->r;
    
    for (int i = 0; i < k; i ++ )
    {
        pre = pcurrent;
        pcurrent = pcurrent->r;
    }
    struct Node* newborn = malloc(sizeof(struct Node));
    
    newborn->val = x;
    newborn->r = pcurrent;
    newborn->l = pre;
    pcurrent->l = newborn;
    pre->r = newborn;
}
 
void removell(struct Node* header, int k)
{
    struct Node* pre = header, *pcurrent = pre->r;
    
    for (int i = 0; i < k - 1; i ++ )
    {
        pre = pcurrent;
        pcurrent = pcurrent->r;
    }
    pre->r = pcurrent->r;
    pcurrent->r->l = pre;
    free(pcurrent);
    pcurrent = NULL;
}
void Tail_Insert(struct Node* header, int x)
{
	struct Node* pre = header;
    while (pre->r != NULL)
    {
		pre = pre->r;
	}
	struct Node* newborn = malloc(sizeof(struct Node));
	newborn->val = x;
	newborn->l = pre;
	newborn->r = NULL;
	pre->r = newborn;	
}
void Print(struct Node* header)
{
    for (struct Node* pre = header->r; pre != NULL; pre = pre->r)
    {
        printf("%d ", pre->val);
    }
    printf("\n");
}
int main()
{
    int m;
    scanf("%d", &m);
    struct Node* header = initial();
    while (m --)
    {
        char op[5];
        scanf("%s", op);
        
        if (!strcmp(op, "L"))
        {
            int x;
            scanf("%d", &x);
            head_insert(header, x);
            Print(header);
        }
        else if (!strcmp(op, "R"))
        {
            int x;
            scanf("%d", &x);
            Tail_Insert(header, x);
            Print(header);
        }
        else if (!strcmp(op, "D"))
        {
            int k;
            scanf("%d", &k);
            removell(header, k);
            Print(header);
           
        }
        else if (!strcmp(op, "IL"))
        {
            int k, x;
            scanf("%d%d", &k, &x);
            if (k >= 1) insert(header, k - 1, x);
            Print(header); 
        }
        else if (!strcmp(op, "IR"))
        {
            int k, x;
            scanf("%d%d", &k, &x);
            insert(header, k, x);
            Print(header);
        }
    }
    
}