C语言数据结构_单链表

已于 2022-05-16 20:42:22 修改
阅读量2.5k 收藏 8
点赞数 1
文章标签： 数据结构
于 2022-04-29 09:49:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61726359/article/details/124475102
版权
本文介绍了链表的基本操作，包括创建头结点、创建节点、打印链表、插入元素（头插、尾插、中间插入、按值插入）、删除元素（按值删除、按位置删除）。此外，还展示了两种不同的实现方式，通过比较不同实现的代码来理解链表操作的原理。
摘要由CSDN通过智能技术生成

单链表

1.创建一个头结点并初始化
自写的


struct Node
{
    int data;          //数据域
    struct Node *next; //指针域
};
//创建一个头节点注意初始化
struct Node *createList()
{
    struct Node *headNode = (struct Node *)malloc(sizeof(struct Node));
    headNode->data = '\0';
    headNode->next = NULL;
    return headNode;
}

在这里插入图片描述

老师的

typedef struct LinkNode{
	char data;
	struct LinkNode *next;
} LNode, *LinkList, *NodePtr;

/**
 * Initialize the list with a header.
 * @return The pointer to the header.
 */
LinkList initLinkList(){
	NodePtr tempHeader = (NodePtr)malloc(sizeof(LNode));
	tempHeader->data = '\0';
	tempHeader->next = NULL;
	return tempHeader;

2.创建结点
自写的

//创建节点
struct Node *creatNode(int data)
{
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

3.打印链表
自写的

//打印链表
void printList(struct Node *headNode)
{
    struct Node *pMove = headNode->next;
    while (pMove != NULL)
    {
        printf("%d ", pMove->data);
        pMove = pMove->next;
    }
    printf("\n");
}

老师的

void printList(NodePtr paraHeader){
	NodePtr p = paraHeader->next;
	while (p != NULL) {
		printf("%c", p->data);
		p = p->next;
	}// Of while
	printf("\r\n");
}

4.插入元素
自写的

//头插法连接各个节点
void insertNodeByHead(struct Node *headNode, int data)
{
    struct Node *newNode = creatNode(data);
    printf("开始从头部连接%d\n", data);
    newNode->next = headNode->next;
    headNode->next = newNode;
}
//尾插法连接各个节点
void insertNodeByTail(struct Node *headNode, int data)
{
    struct Node *newNode = creatNode(data);
    struct Node *pMove = headNode;
    while (pMove->next != NULL)
    {
        pMove = pMove->next;
    }
    printf("开始从尾部连接%d\n", data);
    pMove->next = newNode;
}
//在中间连接一个节点
void insertNodeBymiddle(struct Node *headNode, int data, int position)
{
    struct Node *newNode = creatNode(data);
    struct Node *pMove = headNode;
    for (int i = 0; i < position; i++)
    {
        pMove = pMove->next;
        if (pMove == NULL)
        {
            printf("输入的位置%d超出了链表的最大长不能插入元素。\n", position);
            return;
        }
    }
    //实际上是在该位置的后面插入一个节点
    printf("开始从中间连接%d\n", data);
    newNode->next = pMove->next;
    pMove->next = newNode;
}
//在指定值后面插入一个节点
void insertNodeByData(struct Node *headNode, int paraData, int Data)
{
    struct Node *newNode = creatNode(Data);
    struct Node *pMove = headNode->next;
    while (pMove->data != paraData)
    {
        if (pMove == NULL)
        {
            printf("未能找到该元素，无法添加。\n");
            return;
        }
         pMove = pMove->next;//特别注意这里尤其考虑该值在最后的时候
         //pMove和pMove->next不一样
    }
    printf("在%d后面添加元素%d\n", paraData, Data);
    newNode->next = pMove->next;
    pMove->next = newNode;
}

在这里插入图片描述

老师的

//w尾插法
void appendElement(NodePtr paraHeader, char paraChar){
	NodePtr p, q;

	// Step 1. Construct a new node.
	q = (NodePtr)malloc(sizeof(LNode));
	q->data = paraChar;
	q->next = NULL;

	// Step 2. Search to the tail.
	//找到1尾部
	p = paraHeader;
	while (p->next != NULL) {
		p = p->next;
	}// Of while

	// Step 3. Now add/link.
	p->next = q;
}// Of appendElement

/**
 * Insert an element to the given position.
 * @param paraHeader The header of the list.
 * @param paraChar The given char.
 * @param paraPosition The given position.
 */
//中间插入
void insertElement(NodePtr paraHeader, char paraChar, int paraPosition){
	NodePtr p, q;

	// Step 1. Search to the position.
	p = paraHeader;
	for (int i = 0; i < paraPosition; i ++) {
		p = p->next;
		if (p == NULL) {
			printf("The position %d is beyond the scope of the list.", paraPosition);
			return;
		}// Of if
	} // Of for i

	// Step 2. Construct a new node.
	q = (NodePtr)malloc(sizeof(LNode));
	q->data = paraChar;

	// Step 3. Now link.
	printf("linking\r\n");
	q->next = p->next;
	p->next = q;
}// Of insertElement

5.删除元素
自写的

//链表的指定值的删除方法一
void deleteNodeByAppionWayOne(struct Node *headNode, int posData)
{
    struct Node *posNode = headNode->next;
    struct Node *posNodeFront = headNode;
    if (posNode == NULL)
    {
        printf("链表为空无法删除。\n");
    }
    else
    {
        while (posNode->data != posData)
        {
            posNodeFront = posNode;
            posNode = posNodeFront->next;
            if (posNode == NULL)
            {
                printf("没有找到%d的信息，无法删除。\n", posData);
                return;
            }
        }
        printf("删除%d\n", posData);
        posNodeFront->next = posNode->next;
        free(posNode);
    }
}
//链表的指定值删除方法二
void deleteNodeByAppionWayTwo(struct Node *headNode, int posData)
{
    struct Node *p;
    struct Node *q;
    p = headNode;
    while (p->next != NULL && p->next->data != posData)
    {
        p = p->next;
    }
    if (p->next == NULL)
    {
        printf("没有找到%d的信息，无法删除。\n", posData);
        return;
    }
    printf("删除 %d\n", posData);
    q = p->next;
    p->next = p->next->next;
    free(q);
}
//链表的指定位置删除
void deleteNodeByposition(struct Node *headNode, int position)
{
    struct Node *pMove = headNode;
    struct Node *q;
    if (position <= 0)
    {
        printf("无效位置 %d。\n", position);
        return;
    }
    for (int i = 1; i < position; i++)
    {
        pMove = pMove->next;
    }
    if (pMove->next == NULL)
    {
        printf("要删除的位置 %d 已经超出链表的最大长度不能删除该位置。\n", position);
        return;
    }
    printf("删除位置 %d 的元素\n", position);
    q = pMove->next;
    pMove->next = pMove->next->next;
    free(q);
}

在这里插入图片描述

老师的

void deleteElement(NodePtr paraHeader, char paraChar){
	NodePtr p, q;
	p = paraHeader;
	while ((p->next != NULL) && (p->next->data != paraChar)){
		p = p->next;
	}// Of while

	if (p->next == NULL) {
		printf("Cannot delete %c\r\n", paraChar);
		return;
	}// Of if

	q = p->next;
	p->next = p->next->next;
	free(q);
}// Of deleteElement

6.所有代码
自写的

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

struct Node
{
    int data;          //数据域
    struct Node *next; //指针域
};
//创建一个头节点注意初始化
struct Node *createList()
{
    struct Node *headNode = (struct Node *)malloc(sizeof(struct Node));
    headNode->data = '\0';
    headNode->next = NULL;
    return headNode;
}
//创建节点
struct Node *creatNode(int data)
{
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
//打印链表
void printList(struct Node *headNode)
{
    struct Node *pMove = headNode->next;
    while (pMove != NULL)
    {
        printf("%d ", pMove->data);
        pMove = pMove->next;
    }
    printf("\n");
}
//头插法连接各个节点
void insertNodeByHead(struct Node *headNode, int data)
{
    struct Node *newNode = creatNode(data);
    printf("开始从头部连接%d\n", data);
    newNode->next = headNode->next;
    headNode->next = newNode;
}
//尾插法连接各个节点
void insertNodeByTail(struct Node *headNode, int data)
{
    struct Node *newNode = creatNode(data);
    struct Node *pMove = headNode;
    while (pMove->next != NULL)
    {
        pMove = pMove->next;
    }
    printf("开始从尾部连接%d\n", data);
    pMove->next = newNode;
}
//在中间连接一个节点
void insertNodeBymiddle(struct Node *headNode, int data, int position)
{
    struct Node *newNode = creatNode(data);
    struct Node *pMove = headNode;
    for (int i = 0; i < position; i++)
    {
        pMove = pMove->next;
        if (pMove == NULL)
        {
            printf("输入的位置%d超出了链表的最大长不能插入元素。\n", position);
            return;
        }
    }
    //实际上是在该位置的后面插入一个节点
    printf("开始从中间连接%d\n", data);
    newNode->next = pMove->next;
    pMove->next = newNode;
}
//在指定值后面插入一个节点
void insertNodeByData(struct Node *headNode, int paraData, int Data)
{
    struct Node *newNode = creatNode(Data);
    struct Node *pMove = headNode->next;
    while (pMove->data != paraData)
    {
        pMove = pMove->next;
        if (pMove == NULL)
        {
            printf("未能找到该元素，无法添加。\n");
            return;
        }
    }
    printf("在%d后面添加元素%d\n", paraData, Data);
    newNode->next = pMove->next;
    pMove->next = newNode;
}
//链表的指定值的删除方法一
void deleteNodeByAppionWayOne(struct Node *headNode, int posData)
{
    struct Node *posNode = headNode->next;
    struct Node *posNodeFront = headNode;
    if (posNode == NULL)
    {
        printf("链表为空无法删除。\n");
    }
    else
    {
        while (posNode->data != posData)
        {
            posNodeFront = posNode;
            posNode = posNodeFront->next;
            if (posNode == NULL)
            {
                printf("没有找到%d的信息，无法删除。\n", posData);
                return;
            }
        }
        printf("删除%d\n", posData);
        posNodeFront->next = posNode->next;
        free(posNode);
    }
}
//链表的指定值删除方法二
void deleteNodeByAppionWayTwo(struct Node *headNode, int posData)
{
    struct Node *p;
    struct Node *q;
    p = headNode;
    while (p->next != NULL && p->next->data != posData)
    {
        p = p->next;
    }
    if (p->next == NULL)
    {
        printf("没有找到%d的信息，无法删除。\n", posData);
        return;
    }
    printf("删除 %d\n", posData);
    q = p->next;
    p->next = p->next->next;
    free(q);
}
//链表的指定位置删除
void deleteNodeByposition(struct Node *headNode, int position)
{
    struct Node *pMove = headNode;
    struct Node *q;
    if (position <= 0)
    {
        printf("无效位置 %d。\n", position);
        return;
    }
    for (int i = 1; i < position; i++)
    {
        pMove = pMove->next;
    }
    if (pMove->next == NULL)
    {
        printf("要删除的位置 %d 已经超出链表的最大长度不能删除该位置。\n", position);
        return;
    }
    printf("删除位置 %d 的元素\n", position);
    q = pMove->next;
    pMove->next = pMove->next->next;
    free(q);
}
void allTest()
{
    //创建一个链表
    struct Node *List = createList();
    insertNodeByHead(List, 1);
    insertNodeByHead(List, 2);
    insertNodeByHead(List, 3);
    insertNodeByHead(List, 4);
    printList(List);
    //测试根据元素值删除方法一
    deleteNodeByAppionWayOne(List, 2);
    printList(List);
    deleteNodeByAppionWayOne(List, 7);
    printList(List);
    //测试尾插法
    insertNodeByTail(List, 10);
    printList(List);
    //测试中间插入元素
    insertNodeBymiddle(List, 20, 2);
    printList(List);
    insertNodeBymiddle(List, 11, 10);
    printList(List);
    //测试根据元素值删除方式二
    deleteNodeByAppionWayTwo(List, 10);
    printList(List);
    deleteNodeByAppionWayTwo(List, 2);
    printList(List);
    // 测试根据位置删除
    deleteNodeByposition(List, 0);
    printList(List);
    deleteNodeByposition(List, 1);
    printList(List);
    //测试指定值后面插入元素
    insertNodeByData(List, 20, 23);
    printList(List);
}
int main()
{
    allTest();
}

老师的`

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

/**
 * Linked list of characters. The key is data.
 */
typedef struct LinkNode{
	char data;
	struct LinkNode *next;
} LNode, *LinkList, *NodePtr;

/**
 * Initialize the list with a header.
 * @return The pointer to the header.
 */
//创建链表头结点
LinkList initLinkList(){
	NodePtr tempHeader = (NodePtr)malloc(sizeof(LNode));
	tempHeader->data = '\0';
	tempHeader->next = NULL;
	return tempHeader;
}// Of initLinkList

/**
 * Print the list.
 * @param paraHeader The header of the list.
 *///打印链表
void printList(NodePtr paraHeader){
	NodePtr p = paraHeader->next;
	while (p != NULL) {
		printf("%c", p->data);
		p = p->next;
	}// Of while
	printf("\r\n");
}// Of printList

/**
 * Add an element to the tail.
 * @param paraHeader The header of the list.
 * @param paraChar The given char.
 */
//头插法
void appendElement(NodePtr paraHeader, char paraChar){
	NodePtr p, q;

	// Step 1. Construct a new node.
	//创建一个新的结点
	q = (NodePtr)malloc(sizeof(LNode));
	q->data = paraChar;
	q->next = NULL;

	// Step 2. Search to the tail.
	//找到链表的尾部
	p = paraHeader;
	while (p->next != NULL) {
		p = p->next;
	}// Of while

	// Step 3. Now add/link.
	//连接
	p->next = q;
}// Of appendElement

/**
 * Insert an element to the given position.
 * @param paraHeader The header of the list.
 * @param paraChar The given char.
 * @param paraPosition The given position.
 */
//中间插入
void insertElement(NodePtr paraHeader, char paraChar, int paraPosition){
	NodePtr p, q;

	// Step 1. Search to the position.
	//找到位置
	p = paraHeader;
	for (int i = 0; i < paraPosition; i ++) {
		p = p->next;
		if (p == NULL) {
			printf("The position %d is beyond the scope of the list.", paraPosition);
			return;
		}// Of if
	} // Of for i

	// Step 2. Construct a new node.
	//创建一个新的结点
	q = (NodePtr)malloc(sizeof(LNode));
	q->data = paraChar;

	// Step 3. Now link.
	//连接
	printf("linking\r\n");
	q->next = p->next;
	p->next = q;
}// Of insertElement

/**
 * Delete an element from the list.
 * @param paraHeader The header of the list.
 * @param paraChar The given char.
 */
//删除指定的值
void deleteElement(NodePtr paraHeader, char paraChar){
	NodePtr p, q;
	p = paraHeader;
	while ((p->next != NULL) && (p->next->data != paraChar)){
		p = p->next;
	}// Of while

	if (p->next == NULL) {
		printf("Cannot delete %c\r\n", paraChar);
		return;
	}// Of if

	q = p->next;
	p->next = p->next->next;
	//释放空间
	free(q);
}// Of deleteElement

/**
 * Unit test.
 */
//测试插入删除
void appendInsertDeleteTest(){
	// Step 1. Initialize an empty list.
	LinkList tempList = initLinkList();
	printList(tempList);

	// Step 2. Add some characters.
	appendElement(tempList, 'H');
	appendElement(tempList, 'e');
	appendElement(tempList, 'l');
	appendElement(tempList, 'l');
	appendElement(tempList, 'o');
	appendElement(tempList, '!');
	printList(tempList);

	// Step 3. Delete some characters (the first occurrence).
	deleteElement(tempList, 'e');
	deleteElement(tempList, 'a');
	deleteElement(tempList, 'o');
	printList(tempList);

	// Step 4. Insert to a given position.
	insertElement(tempList, 'o', 1);
	printList(tempList);
}// Of appendInsertDeleteTest

/**
 * Address test: beyond the book.
 */
//地址测试
void basicAddressTest(){
	LNode tempNode1, tempNode2;

	tempNode1.data = 4;
	tempNode1.next = NULL;

	tempNode2.data = 6;
	tempNode2.next = NULL;

	printf("The first node: %d, %d, %d\r\n",
		&tempNode1, &tempNode1.data, &tempNode1.next);
	printf("The second node: %d, %d, %d\r\n",
		&tempNode2, &tempNode2.data, &tempNode2.next);

	tempNode1.next = &tempNode2;
}// Of basicAddressTest

/**
 * The entrance.
 */
int main(){
	appendInsertDeleteTest();
    basicAddressTest();
}// Of main

7.测试结果
自写的

开始从头部连接1
开始从头部连接2
开始从头部连接3
开始从头部连接4
4 3 2 1
删除2
4 3 1
没有找到7的信息，无法删除。
4 3 1
开始从尾部连接10
4 3 1 10
开始从中间连接20
4 3 20 1 10
输入的位置10超出了链表的最大长不能插入元素。
4 3 20 1 10
删除 10
4 3 20 1
没有找到2的信息，无法删除。
4 3 20 1
无效位置 0。
4 3 20 1
删除位置 1 的元素
3 20 1
在20后面添加元素23
3 20 23 1

老师的

Hello!
Cannot delete a
Hll!
linking
Holl!
The first node: 6421984, 6421984, 6421992
The second node: 6421968, 6421968, 6421976
百年孤独z
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构(C++) - 实现带头节点单链表
指尖上跳转
07-24 562
线性表的链式存储又称单链表。 特点: 不需要使用地址连续的存储单元 插入和删除操作不需要移动元素 非随机存取 附加指针域，存在浪费存储空间的缺点 /* LinkList.h */ #pragma once #include <iostream> using namespace std; /* 节点结构体 */ template <class DataType> struct Node { DataType data; struct Node* next; Node() {
【Data Struct】单链表
谢军的博客
12-02 616
单链表的创建#include<stdio.h> #include<stdlib.h>typedef struct node { int data; struct node * next; }LNode, *LinkList; // LNode是节点结构体，LinkList是节点结构体指针LinkList create_list() { LinkList head; h
带头结点的单链表的创建
weixin_30294709的博客
02-01 468
#include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *next; }Node; Node* CreatList(int n) { Node *head,*p,*q; head=(Node*)malloc(s...
数据结构—带头结点的单链表
weixin_68908154的博客
02-15 2017
带头结点的单链表结构设计、接口函数设计、接口函数实现
带头结点的单链表
HPAlways的博客
03-26 730
创建了一个带头结点的单链表，并且实现了这个带头结点的单链表的翻转和删除某个值,附上完整代码
例子_C语言_单链表_数据结构_源码
10-04
单链表作为一种基本的数据结构，广泛应用于各种编程语言，包括C语言。本篇将深入探讨C语言实现单链表的相关知识点。 单链表是一种线性数据结构，其中每个元素（称为节点）包含两个部分：数据域和指针域。数据域存储...
C语言单链表实现19个功能完全详解.zip_C语言_C语言单链表_单链表
09-20
在C语言中，单链表是一种基础且重要的数据结构，它在编程中有着广泛的应用。本文将详细解析如何使用C语言来实现单链表，并涵盖了19种不同的操作功能，帮助你深入理解这一核心概念。 单链表由一系列节点组成，每个...
C语言顺序表_单链表_双链表代码.zip
03-30
本压缩包"**C语言顺序表_单链表_双链表代码.zip**"提供了C语言实现的三种基本数据结构——顺序表、单链表和双链表的源代码，这些代码适用于初学者学习和实践。以下将详细介绍这三种数据结构及其应用。 **1. 顺序表*...
guofu11111111111111.rar_单链表_单链表 c语言_线性链表程序
07-13
在IT领域，单链表是一种基础且重要的数据结构，它在C++编程中扮演着核心角色。本项目涉及的是一个用C++实现的非递减单链表，它具有带头节点，可以执行多种操作，如初始化、销毁、插入、删除、清空以及打印线性表。...
C语言 数据结构之单链表基本操作
10-05
单链表的各种操作，适合于初学，也适合于复习 单链表操作介绍 1. 创建头节点 2. 创建有数据节点 3. 判断链表是否为空 4. 遍历链表(有头节点链表) 5. 遍历链表(无头节点链表) 6. 头插、头删、尾插、尾删 7. 按照顺序...
【数据结构】-单链表(带头结点）
RunningSnail的博客
07-18 2821
单链表-带头结点1.头文件及类型定义2.单链表结点类型定义3.函数声明4.基本操作4.1 初始化单链表4.2 判空4.3 插入操作4.3.1 按位插入4.3.2 指定结点插入4.3.2.1 指定结点后插4.3.2.2 指定结点前插4.3.2.2.1 前插法1(时间复杂度为O(n))4.3.2.2.2 前插法2(时间复杂的为O(1))4.4 删除操作4.4.1 按位删除4.4.2 指定结点删除4.4.2.1 删除法1(时间复杂度为O(n))4.4.2.2 删除法2(时间复杂度为O(1))4.5 查找操作4.5
【数据结构】·【带头结点的单链表】
墨突不黔
01-25 1117
比较坑爹的基础啊，大把时间浪费在构造函数上，构造函数（出生决定命运！）。 自己解决的bug,感觉还不错。其实程序的核心是算法，算法建立在数据结构的基础之上。 大部分的程序员现在学的基本都是规则，而不是创造。 但掌握了规则，也能创造很多财富。 重新巩固我弱爆了的数据结构，没敲完数据结构的程序员不是好领导。 注释就不写了，可以提问，或者建议。 #include #include #incl
C语言笔记：结构体
m0_62934529的博客
03-18 455
1. 结构体的声明 1.1 结构的基础知识 结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。如：对于人来说，姓名，年龄，性别等就是成员变量 1.2 结构的声明 struct tag //声明一个结构体类型，并不占用空间 { member-list; }variable-list; 如：声明一个结构体类型 - 书： #include <stdio.h> #include <string.h > //声明了一个结构体类型 - 书
数据结构：C语言实现----带头结点的单链表
kimEHEH的博客
08-12 1034
带头结点的单链表 特点： ①头结点定义在栈区，不保存数据，起标记作用，不参与具体运算。 ②其他数据结点在堆区，动态申请内存/ 带头结点的单链表结构体声明 typedef struct Node { int data; struct Node *next; }Node, *LinkList; （1）初始化：头结点本身已存在，只需将头的next置为NULL void InitLinkList(LinkList plist) { assert(plist != NULL); if(plist == NU
C++实现带头节点的单链表
Tra_cy的博客
09-16 998
# include <iostream> #include <cstdlib> using namespace std; //定义一个节点类 typedef struct Node { /* data */ int data; //数据域 Node *next; //指针域 }; //构建一个单链表类 class SLinkList { private: Node *head; public: SLinkList(/* args *
【数据结构】设L为带头结点的单链表，数据为整型。编写函数，删除重复结点(具有多个相同值的结点只保留一个)
每天进步一点丶的博客
02-23 2674
文章目录1.算法思想2.定义结构体3.函数实现4.测试结果5.完整代码 1.算法思想 对于删除单链表重复结点的问题，最简单的方法就是设置一个前驱指针: 遍历链表和当前值进行比较 判断是删除结点还是跳过该结点，比较下一个结点 由于设置了前驱结点，因此进行结点的删除将比较简单 2.定义结构体 定义链表结构体 typedef struct LNode { int data; struct LNode *next; } LNode, *LinkList; 3.函数实现 设置三个工作指针即可实现
C语言实现单链表(带头结点的)
maniac_ran的博客
04-03 2593
在用结构体写单链表时，需要先了解指针 #include<stdio.h> #include<stdlib.h> struct Node { int data; struct Node *next; }; //1.创建一个表头，表示整个链表 struct Node* createlistHead() { //链表的基本单元是结构体 //动态申请内存，将结构体...
【数据结构】给定一个带头结点的单链表L，设head为头指针，结点的结构为（data，next），data为整型元素，next为指针。
weixin_51280571的博客
08-08 4725
题目：给定一个带头结点的单链表L，设head为头指针，结点的结构为（data，next），data为整型元素，next为指针。设计算法，将L逆置，要求算法的空间复杂度为O(1)。3.确定采用头插法，因为用该方法建立链表，得到链表中元素的顺序和输入的顺序相反，可以利用这一个特点，将单链表逆置；最好的情况就是链表长度只有1，无需逆置，最坏的情况使链表长度为n，就需要进循环n次。1.理解算法空间复杂度为O（1），即为没有申请额外的空间；当链表长度为1时，while循环里的语句执行1次；（1）给出算法的设计思想。.
数据结构-带头节点的单链表（C语言）超详细讲解
热门推荐
m0_56992713的博客
10-17 2万+
前面我们学到线性表的顺序存储结构（顺序表），发现它有着明显的缺点：插入和删除元素时需要频繁的移动元素，运算效率低。必须按事先估计的最大元素个数申请连续的存储空间。存储空间估计大了，造成浪费空间；估计小了，容易产生溢出，空间难以扩大。 采用链式存储结构的线性表（链表）可以克服以上的不足。 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(存放的数据元素)+指针(指示下一个元素存储位置，单、双链表的最后一个节点除外，它们.
c语言实现数据结构单链表
最新发布
06-06
好的，下面是一个使用C语言实现单链表的例子： ```c #include <stdio.h> #include <stdlib.h> typedef struct node { int value; struct node *next; } Node; typedef struct linked_list { Node *head; } LinkedList; void add(LinkedList *list, int value) { Node *newNode = (Node*)malloc(sizeof(Node)); newNode->value = value; newNode->next = NULL; if (list->head == NULL) { list->head = newNode; } else { Node *current = list->head; while (current->next != NULL) { current = current->next; } current->next = newNode; } } void removeNode(LinkedList *list, int value) { if (list->head == NULL) { return; } if (list->head->value == value) { Node *temp = list->head; list->head = list->head->next; free(temp); return; } Node *current = list->head; while (current->next != NULL && current->next->value != value) { current = current->next; } if (current->next != NULL) { Node *temp = current->next; current->next = current->next->next; free(temp); } } void print(LinkedList *list) { Node *current = list->head; while (current != NULL) { printf("%d ", current->value); current = current->next; } printf("\n"); } int main() { LinkedList *list = (LinkedList*)malloc(sizeof(LinkedList)); list->head = NULL; add(list, 1); add(list, 2); add(list, 3); print(list); removeNode(list, 2); print(list); return 0; } ``` 这个单链表包含了三个函数：add、removeNode和print。add函数用于向单链表中添加一个元素，removeNode函数用于从单链表中删除一个元素，print函数用于打印单链表中所有元素的值。使用这个单链表，我们可以方便地对一系列元素进行管理和操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值