链表操作

已于 2023-02-07 12:08:07 修改
阅读量213 收藏
点赞数
分类专栏： 算法 文章标签： 链表 数据结构 算法 c语言 c++
于 2020-03-13 23:09:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangjinjingbj/article/details/104851922
版权 
#include <stdio.h>
#include <stdlib.h>

typedef struct node
{
    int data;
    struct node *next;
}node_t;

node_t *make_node(int val)
{
    node_t *p = (node_t *)malloc(sizeof(node_t));
    if(p)
	{
        p->data = val;
        p->next = NULL;
    }
    return p;
}

node_t *link_insert1(node_t *head, int val)//insert end
{
    node_t *insertp = make_node(val);
    node_t *tail;

    if(insertp == NULL || head == NULL)
	{
        if(head == NULL)
		{
            head = insertp;
        }
        return head;
    }
    for(tail = head; tail->next; tail = tail->next)
        ;
    tail->next = insertp;
    return head;
}

node_t *link_insert2(node_t *head, int val)//insert head
{
    node_t *insertp = make_node(val);

    if(insertp == NULL && head != NULL)
	{
        return head;
    }
    insertp->next = head;
    head = insertp;
    return head;
}

node_t *link_insert3(node_t *head, int val)//sort insert
{
    node_t *insertp = make_node(val), *pre, *cur;
    
    if(insertp == NULL || head == NULL)
	{
        if(head == NULL)
            head = insertp;
        return head;
    }
    for(pre = cur = head; cur && cur->data < val; pre = cur, cur = cur->next)    
        ;
    if(cur == head)
	{
        insertp->next = head;
        head = insertp;
    }
	else
	{
        pre->next = insertp;
        insertp->next = cur;
    }
    return head;
}

void link_print(node_t *head)
{
    node_t *cur;

    for(cur = head; cur; cur = cur->next)
        printf("--%d--\n", cur->data);
}

void link_destroy(node_t *head)
{
    node_t *cur, *next;

    for(cur = head; cur; cur = next)
	{
        next = cur->next;
        free(cur);
    }
}

node_t *link_remove(node_t *head, int val)
{
    node_t *rmp = NULL, *pre, *cur;
    if(head == NULL)
        return NULL;
    if(head->data == val)
	{
        rmp = head;
        head = head->next;
        return rmp;
    }
    for(pre = head, cur = head->next; cur; pre = pre->next, cur = cur->next)
	{
        if(cur->data == val)
		{
            rmp = cur;
            pre->next = cur->next;
            rmp->next = NULL;
            return rmp;
        }
    }
    return NULL;
}

int main(void)
{
    int n;
    node_t *head = NULL, *rmp;

    while(1)
	{
        scanf("%d", &n);
        if(n == 0)
            break;
        head = link_insert3(head, n);
    }

    rmp = link_remove(head, 3);
    link_print(head);
    link_destroy(head);
    return 0;
}

linklist reverse

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

#define LEN 5 

typedef struct node
{
    int n;
    struct node *next;
}node_t;

node_t *create(node_t *head, int len)
{
    int i;
    node_t *cur, *tail;

    for(i = 0; i < len; i++)
	{
        cur = (node_t *)malloc(sizeof(node_t));
        cur->n = i;
        cur->next = NULL;
        if(i == 0)
            head = cur;
        else
            tail->next = cur;
        tail = cur;
    }

    return head;
}

/*
node_t *reverse(node_t *head)
{
    node_t *pre, *next, *cur;
    int i = 1;

    pre = head;
    cur = next = head->next;
    while(cur){
        printf("i = %d\n", i++);
        next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }
    head->next = NULL;
    head = cur;
    return pre;
}
*/

node_t *reverse(node_t *head)
{
	if(head == NULL || head->next == NULL)
		return head;

    node_t *pre = head;
	node_t *cur = pre->next;
	node_t *next = cur->next;

    pre->next = NULL;
    while(next != NULL)
	{
        cur->next = pre;
        pre = cur;
        cur = next;
		next = next->next;
    }
    cur->next = pre;
    head = cur;

    return head;
}

int main(void)
{
    node_t *head = NULL, *cur, *del;
    head = create(head, LEN);

    for(cur = head; cur != NULL; cur = cur->next)
	{
        printf("--%d--", cur->n);
    }
    printf("\n");
    head = reverse(head);

    cur = head;
    while(cur != NULL)
	{
        printf("==%d==", cur->n);
        del = cur;
        cur = cur->next;
        free(del);
    }
    printf("\n");

    return 0;
}

/*
判断链表中是否有环
*/

#include <stdio.h>
#include <stdlib.h>
//#include "stdafx.h"

#define NUM 10

typedef struct node
{
    unsigned n;
    struct node *next;
}node_t;

node_t *create(node_t *head, int len)
{
    int i;
    node_t *cur, *tail;

    for(i = 0; i < len; i++)
	{
        cur = (node_t *)malloc(sizeof(node_t));
        if(cur == NULL)
		{
            perror("malloc fail");
            exit(1);
        }
        cur->n = i + 1;
        cur->next = NULL;
        if(i == 0)
		{
            head = tail = cur;
		}
		else
		{
            tail->next = cur;
            tail = cur;
        }
    }
    tail->next = head;

    return head;
}

int main(void)
{
    node_t *head = NULL, *cur, *pre;

    head = create(head, NUM);

    pre = cur = head;
    while(1)
	{
        pre = pre->next;
        cur = cur->next->next;
        if(pre == NULL || cur == NULL)
		{
            printf("No Ring!\n");
            return 0;
        }
        if(pre == cur)
		{
            printf("Ring occurred!\n");
            return 0;
        }
    }
    return 0;
}

//add 计算，两个数位数相等，或head1 >head2

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

typedef struct node
{
    unsigned int n;
    struct node *next;
}node_t;

node_t *creat(node_t *head, char *str)
{
    char *bkup = str;
    node_t *cur;

    while(*bkup)
	{
        cur = malloc(sizeof(node_t));
        cur->n = *bkup - '0';
        cur->next = head;
        head = cur;

        bkup++;
    }
    return head;
}

void show(node_t *head)
{
    node_t *cur = head;

    while(cur)
	{
        printf("%d ", cur->n);
        cur = cur->next;
    }
    printf("\n");
}

node_t *add(node_t *head1, node_t *head2, node_t *head)
{
    node_t *cur;
	node_t *cur1 = head1;
	node_t *cur2 = head2;
    int oldcarry = 0, sum = 0;

    while(cur1 || oldcarry)
	{
        if(cur1)
		{
            sum = cur1->n + cur2->n;
            cur1 = cur1->next, cur2 = cur2->next;
        }
        sum += oldcarry;

        printf("sum = %d, oldcarry = %d\n", sum, oldcarry);
        cur = malloc(sizeof(node_t));
        if(sum >= 10)
		{
            cur->n = sum - 10;
            oldcarry = 1;
        }
		else
		{
            cur->n = sum;
            oldcarry = 0;
        }
        sum = 0;

        cur->next = head;
        head = cur;
    }
    return head;
}

int main(int argc, char *argv[])
{
    node_t *head1 = NULL, *head2 = NULL, *head = NULL;

    head1 = creat(head1, "11111");
    head2 = creat(head2, "54321");

    show(head1);
    show(head2);

    head = add(head1, head2, head);
    show(head);
    return 0;
}

/*
双向链表的实现
*/

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

#define LENGTH 3
typedef struct node *link_t;

typedef struct node
{
	int data;
	link_t prev;
	link_t next;
}node_t;

static link_t head = NULL;
static link_t tail = NULL;

link_t make_node(int item)
{
	link_t p = (node_t *)malloc(sizeof(node_t));
	if (p != NULL)
	{
		p->data = item;
		p->prev = p->next = NULL;
	}
	return p;
}

void free_node(link_t p)
{
	free(p);
}

link_t link_search(int key)
{
	link_t p;

	for (p = head->next; p != tail; p = p->next)
	if (p->data == key)
		return p;
	return NULL;
}

void link_delete(link_t p)
{
	p->prev->next = p->next;
	p->next->prev = p->prev;
}

void link_traverse(void(*visit)(link_t))
{
	link_t p;
	for (p = head->next; p != NULL; p = p->next)
		visit(p);
}

void link_destroy(void)
{
	link_t q, p = head->next;
	head->next = tail;
	tail->prev = head;
	while (p != tail)
	{
		q = p;
		p = p->next;
		free_node(q);
	}
}

void link_print(link_t p)
{
	printf("%d\n", p->data);
}

void link_insertByHead(link_t p)
{
	p->prev = head;
	p->next = head->next;

	if (head->next != NULL)//如果不是第一次插入，要注意下  
		head->next->prev = p;
	head->next = p;
}

void link_insertByTail(link_t p)
{
	p->prev = tail;
	p->next = NULL;
	tail->next = p;
	tail = p;
}

link_t CreateDbLinkList(void)
{
	int i = 0, length = 0, data = 0;
	link_t node = NULL;
	head = tail = (link_t)malloc(sizeof(node_t));
	if (NULL == head)
	{
		printf("内存分配失败！\n");
		exit(EXIT_FAILURE);
	}
	head->next = NULL;
	head->prev = NULL;
	tail->next = NULL;
	tail->prev = NULL;
	for (i = 1; i <= LENGTH; i++)
	{
		node = make_node(i);
		node->data = i;
		link_insertByHead(node);
	}

	return head;
}

int main(void)
{
	head = CreateDbLinkList();
	link_traverse(link_print);

	link_t p = link_search(2);
	link_delete(p);
	free_node(p);
	link_traverse(link_print);

	link_t q = make_node(4);
	link_insertByHead(q);
	link_traverse(link_print);

	link_destroy();
	return 0;
}

/*
双向链表实现一个队列
*/
#include <stdio.h>
#include <stdlib.h>

#define LENGTH 5

typedef struct node 
{
	int data;
	node* prev;
	node* next;
} Node;

typedef struct queue 
{
	Node* head;
	Node* tail;
} LinkDQueue;

//创建队列函数
LinkDQueue* CreatDQueuelist() 
{
	LinkDQueue* queue = (LinkDQueue *)malloc(sizeof(LinkDQueue));
	queue->head = queue->tail = (Node *)malloc(sizeof(Node));
	queue->head->data = 0;
	queue->head->prev = NULL;
	queue->head->next = NULL;

	for (int i = 1; i <= LENGTH; i++)  
	{
		Node* pnew = (Node *)malloc(sizeof(Node));
		if (NULL == pnew)
			printf("内存分配失败!");
		pnew->data = i;
		pnew->next = NULL;
		queue->tail->next = pnew;
		pnew->prev = queue->tail;
		queue->tail = pnew;
	}

	return queue;
}

//入队函数
void EnDQueuelist(LinkDQueue* q, int e) 
{
	int n = 0;
	Node* tmp = (Node *)malloc(sizeof(Node));
	tmp->data = e;
	if (q->head == q->tail) 
	{
		q->tail->next = tmp;
		tmp->prev = q->tail;
		tmp->next = NULL;
		q->tail = tmp;
		return;
	}
	tmp->next = NULL;
	q->tail->next = tmp;
	tmp->prev = q->tail;
	q->tail = tmp;
}

int DeDQueuelist(LinkDQueue* q) 
{
	int data = 0;
	if (!q || q->head == q->tail) 
	{
		printf("队列为空!");
		return data;
	}
	Node* tmp = NULL;
	tmp = q->head->next;
	data = tmp->data;
	q->head->next = tmp->next;

	if (q->tail == tmp) 
		q->tail = q->head;
	else
		tmp->next->prev = q->head;
	free(tmp);

	return data;
}

void PrintDQueuelist(LinkDQueue* q) 
{
	Node * tmp = q->head->next;
	while (tmp)
	{
		printf("%d ", tmp->data);
		tmp = tmp->next;
	}
}

int GetlengthDQueuelist(LinkDQueue* q) 
{
	int length = 0;
	Node* tmp = q->head->next;
	while (tmp) 
	{
		length++;
		tmp = tmp->next;
	}
	return length;
}

int main() 
{
	LinkDQueue* queue = CreatDQueuelist();
	PrintDQueuelist(queue);
	int a = GetlengthDQueuelist(queue);
	printf("%d\n", a);

	EnDQueuelist(queue, 4);
	PrintDQueuelist(queue);
	a = GetlengthDQueuelist(queue);
	printf("%d\n", a);

	DeDQueuelist(queue);
	PrintDQueuelist(queue);
	return 0;
}
春夏与冬
关注
专栏目录
C语言链表操作详解
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
链表操作演示程序Java版
01-19
在这个“链表操作演示程序Java版”中，我们看到开发者利用Java语言和JavaFX库创建了一个可视化工具，用于展示链表的各种操作。JavaFX是一个用于构建桌面、移动和嵌入式平台的富客户端应用程序的开源框架。 1. **...
C语言链式栈
weixin_44230855的博客
08-03 200
#include<stdio.h> #include<stdlib.h> struct Node{ char data; struct Node* next; }; struct stack{ struct Node* stackTop; int size; }; struct Node* createNode(char data){ struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
hashmap是单向链表吗_面试中HashMap链表成环的问题你答出了吗
weixin_39633102的博客
01-04 159
HashMap作为老生常谈的问题，备受面试官的青睐，甚至成为了面试必问的问题。由于大量的针对HashMap的解析横空出世，面试官对HashMap的要求越来越高，就像面试官对JVM掌握要求越来越高一样，今天我们来研究下HashMap的链表环化的问题，你知道其中的原理嘛？在JDK1.7版本下，有个线程安全的问题，经常会被问到，很多求职者可能还在对比Hashtable线程安全性...
C语言数据结构——链表
JianZha
04-09 549
#include<stdio.h> #include<malloc.h> #include<stdlib.h> typedef struct Node { int data; // 数据域 struct Node * pNext; // 指针域 }* PNODE, NODE; //NODE等价于struct Node ； PNODE等价于struct Node * PNODE create_list(); void traverse_l
C语言学习之单链表整合
永不秃头的程序员的博客
09-17 692
文章目录一、单链表的实现1.1链表的节点1.2 堆内存的使用 一、单链表的实现 1.1链表的节点 节点里面有两个区域，一个数据域，一个指针域。 struct node { int data; //数据域，可以再加数据以及数据类型。 struct node *next; //指向下一个节点的指针 }; struct node只是一个结构体，不占用内存，本身也没有变量生成。只是一节点的模板，在以后实际需要中直接调用这个模板。 1.2 堆内存的使用 为什么要用堆内存，前面关于内存的时候说过，堆的内存
linklist c语言,C语言实现LinkedList链表数据结构
weixin_33346418的博客
05-19 1189
#include /* 基础头文件*/#include /*动态分配内存头文件*/#include /*返回布尔值的头文件*//****zhouzhongqing*链表List*2017年10月28日14:56:19*/typedef struct Node{ //非循环单链表结构体int data; //数据区域Node * pNext; // 指针指向下一个节点} NODE,*PNOD...
lianbiao.rar_链表基本操作_链表操作
09-24
- **链表的合并与排序**：在排序链表或合并两个已排序链表时，链表操作尤为重要，如归并排序、插入排序等。 - **链表的反向**：将链表的顺序反转，这涉及到对节点的重新连接。 链表是数据结构中的基础，理解和...
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
C语言是实现链表操作的常用工具，它提供了丰富的指针操作功能，使得我们能方便地创建、插入、删除和遍历链表节点。"C11.C"文件很可能包含了实现这些操作的代码，例如： 1. **链表的创建**：首先，需要定义链表节点...
c语言编程题之链表操作设计链表.zip
最新发布
03-30
链表是一种重要的数据结构，在...通过解决此类链表操作的编程题目，你可以深入理解链表数据结构，提高C语言编程能力，同时对动态内存管理和指针操作有更清晰的认识。实践中不断练习，才能更好地掌握这些核心概念。
c语言linklist及各种功能并实现token令牌仿真
07-13
这是一门操作系统课程的作业 c语言实现linkedlist插入，删除，追加节点，等等功能，并仿真计算机里的令牌机制
C#数据结构之单链表(LinkList)实例详解
东方猫的博客
06-03 4889
本文实例讲述了C#数据结构之单链表(LinkList)实现方法。分享给大家供大家参考，具体如下：这里我们来看下“单链表(LinkList)”。在上一篇《C#数据结构之顺序表(SeqList)实例详解》的最后，我们指出了：顺序表要求开辟一组连续的内存空间，而且插入/删除元素时，为了保证元素的顺序性，必须对后面的元素进行移动。如果你的应用中需要频繁对元素进行插入/删除，那么开销会很大。而链表结构正好相...
java-集合-List接口（详解）
weixin_42158022的博客
10-31 466
本篇以List接口的特点和方法为纲，加之以代码验证，清晰明了~ 1、List集合存储元素特点：有序可重复 有序：List集合中的元素有下标。 从0开始，以1递增。 可重复：存储一个1，还可以再存储1. 2、List既然是Collection接口的子接口，那么肯定List接口有自己“特色”的方法： 以下只列出List接口特有的常用的方法： void add(int index, Object element) Object set(int index, Object element) Object get(i
数据结构：单链表（LinkList）基本操作的算法描述（C语言）
weixin_70911939的博客
04-06 916
数据结构：单链表（LinkList）基本操作的算法描述（C语言）
C语言基础编程——链表（一）
weixin_43958845的博客
05-25 1572
一、静态链表 #include<stdio.h> #include<stdlib.h> typedef struct node { int data;///数据域 struct node* next;///指针域 }; int main() { system("color 7D");//背景颜色 struct node node1={1,NULL}; struct node node2={2,NULL}; struct node n
C/C++ 如何实现和使用链表（linked list）
ZhongUncle的博客
08-17 1077
由于实现链表（Linked List）是实现一种数据结构，使用结构体（structure），而不是必须使用 Class。所以 C 和 C++ 没区别。
C语言每日一题（四）
万里羊的博客
12-06 3950
C语言作为嵌入式Linux开发的必备工具，作为嵌入式Linux开发的基础语言，那么在面试嵌入式工程师时C语言定是面试中的重中之重 。作为一名大三的老学长，不得不为找工作做必要准备。每天做一道C语言面试题，为面试打基础。
C语言 数据结构 结构体 LinkList
hpu_yangchen的博客
06-07 4909
C语言结构体 结构体的定义 结构体是c编程中一种用户可自定义的数据类型，它允许你存储不同的数据类型的数据项。 为了定义结构，必须使用struct语句。struct语句定义了一个包含多个成员的新的数据类型。 struct tag{ Elemtype name1; Elemtype name2; }variable-name; 其中tag为结构体标签，Elemtype代表数据类型，比如说int，float，char等，name是变量名，variable-name代表这个结构体的变量名称。 定义
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

春夏与冬

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值