单链表操作（C语言）含注释

最新推荐文章于 2024-01-07 22:14:26 发布
最新推荐文章于 2024-01-07 22:14:26 发布
阅读量420 收藏 5
点赞数
分类专栏： 数据结构与算法实训 文章标签： c语言 数据结构 算法 排序算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_62925086/article/details/129151598
版权
该程序实现了单链表的一系列操作，包括初始化、显示、查找、插入、删除、选择法排序、链表逆置、合并两个有序链表以及按奇偶序号分解链表。特别地，选择法排序通过找到最小值并插入新链表的方式完成，链表合并则通过求交集并排序来实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、创建

2、显示

3、查找（显示比较次数）

4、插入

5、删除（显示比较次数）

6、将链接存储线性表逆置，即最后一个结点变成第1个结点，原来倒数第2个结点变成第2个结点，如此等等。

7、生成有序的两个单链表A和B（链表的数据和个数自定），其首结点指针分别为a和b，要求将两个单链表合并为一个有序的单链表C，其首结点指针为c，并且合并后的单链表的数据不重复。

8、将一个首结点指针为a的单链表A分解成两个单链表A和B，其首结点指针分别为a和b，使得链表A中含有原链表A中序号为奇数的元素，而链表B中含有原链表A中序号为偶数的元素，且保持原来的相对顺序。

单链表操作菜单如下图所示:

以下已给出：

公用的等待函数

void wait()
{
    cout << "\n\n请按任意键继续" << flush;
    getch();
}

屏幕提示后，从键盘输入线性表长度和随机数种子，生成以DLList为头指针的指定长度的线性表

void init(Node *DLList)
{
    int length;
    Node *p,*q;
    while (1)
    {
        cout << "输入元素个数（0－" << 10000 << "）：" << flush;
        cin >> length;
        if (length >= 0 && length <= 10000)
            break;
        cout << endl;
    }

        int i;
    while (1)
    {
        cout << "输入随机数种子（0－32767）：" << flush;
        cin >> i;
        if (i >= 0 && i <= 32767)
            break;
        cout << endl;
    }

    //从线性表中删除并释放原有的结点，使其成为空表
    p=DLList;
    while (p->next!=NULL)
    {
        q=p->next;
        p->next=q->next;
        free(q);
    }

    srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
    rand();  

    //向线性表插入length个新结点
    for (int j=1;j<=length;j++)    
    {
        p=new Node;
        p->next=DLList->next;
        DLList->next=p;
        p->elem=rand() % 10000;
    }
}

一些个人感想：

我认为链表合并有些瑕疵，写的并不好；选择法排序那里不是很能理解透彻，个人认为可以偷懒，利用插入函数把一个个排好的数据插入一个新链表，在把旧链表等于新链表，但这样又不是很符合选择排序的思想。

这4行关键代码理解了蛮久的

temp=min->next;
min->next=temp->next;//将本循环的最小值从链表删除
temp->next=p->next;
p->next=temp;//将本循环的最小值插入链表

全部代码如下：

#include <iostream>
#include <iomanip>
#include <conio.h>
#include <stdio.h>
#include <process.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
using namespace std;

//定义结点类型
struct Node
{
    int elem;
    Node *next;
};

Node Head;       //头结点
Node *DLList;    //头指针

void init(Node *DLList);
void display(Node *DLList);
void insert(Node *DLList);
void search(Node *DLList);
void del(Node *DLList);
void wait();
void selectionSort(Node *DLList);
void listReverse(Node *DLList);
void listMerge(Node *DLList);
void listSplit(Node *DLList);

bool empty(Node *DLList);
void elemInsert(Node *DLList,int data);
int length(Node *DLList);

int main()
{
    char choice;

    DLList=&Head;     //使头指针指向头结点
    Head.next=NULL; 

    while (1)
    {
        system("cls");
        cout << "\n\n\n\n";
        cout << "\t\t              单链表操作  \n";
        cout << "\t\t======================================";
        cout << "\n\n";
        cout << "\t\t             1：初始化      \n";
        cout << "\t\t             2：显示        \n";
        cout << "\t\t             3：单个插入    \n";
        cout << "\t\t             4：查找        \n";
        cout << "\t\t             5：删除        \n";
        cout << "\t\t             6：选择法排序   \n";
        cout << "\t\t             7：逆置链表     \n";
        cout << "\t\t             8：合并两链表   \n";
        cout << "\t\t             9：拆分链表     \n";
        cout << "\t\t             0：退出        \n";
        cout << "\n";
        cout << "\t\t请选择：" << flush;

        choice = getch();
        system("cls");
        
        switch(choice)
        {
            case '1':
                init(DLList);
                wait();
                break;
            case '2':
                display(DLList);
                wait();
                break;
            case '3':
                insert(DLList);
                wait();
                break;
            case '4':
                search(DLList);
                wait();
                break;
            case '5':
                del(DLList);
                wait();
                break;
            case '6':
                selectionSort(DLList);
                wait();
                break;
            case '7':
                listReverse(DLList);
                wait();
                break;
            case '8':
                listMerge(DLList);
                wait();
                break;
            case '9':
                listSplit(DLList);
                wait();
                break;
            case '0':
                exit(0);
        }
    }
}

//公用的等待函数
void wait()
{
    cout << "\n\n请按任意键继续" << flush;
    getch();
}

//屏幕提示后，从键盘输入线性表长度和随机数种子，生成以DLList为头指针的指定长度的线性表
void init(Node *DLList)
{
    int length;
    Node *p,*q;
    while (1)
    {
        cout << "输入元素个数（0－" << 10000 << "）：" << flush;
        cin >> length;
        if (length >= 0 && length <= 10000)
            break;
        cout << endl;
    }

        int i;
    while (1)
    {
        cout << "输入随机数种子（0－32767）：" << flush;
        cin >> i;
        if (i >= 0 && i <= 32767)
            break;
        cout << endl;
    }

    //从线性表中删除并释放原有的结点，使其成为空表
    p=DLList;
    while (p->next!=NULL)
    {
        q=p->next;
        p->next=q->next;
        free(q);
    }

    srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
    rand();  

    //向线性表插入length个新结点
    for (int j=1;j<=length;j++)    
    {
        p=new Node;
        p->next=DLList->next;
        DLList->next=p;
        p->elem=rand() % 10000;
    }
}

//在屏幕上依次显示以DLList为头指针的线性表中的全部元素和元素个数
//格式应便于观察
//如果需要指定输出的宽度，可以使用 cout << setw(W) << X ，其中 X 是输出的数值，W 是占据的列数
void display(Node *DLList)
{
    if(empty(DLList))
        return;
    Node *p=DLList->next;
    int i=1;//控制换行
    while(p!=NULL)
    {
        cout <<setiosflags(ios::left)/*左对齐*/<< setw(15) << p->elem;
        if(i%10==0) printf("\n");
        i++;
        p=p->next;
    }
    printf("\n此表中共有%d个元素！\n",length(DLList));
    
}

//屏幕提示后，从键盘输入一个元素值，然后把这个新元素插到以DLList为头指针的线性表的末尾
void insert(Node *DLList)
{
    int i;
    Node *p=DLList,*temp;
    while(p->next!=NULL)
        p=p->next;
    temp=new Node;
    printf("请输入插入元素的值：");
    scanf("%d",&temp->elem);//数据域
    temp->next=NULL;//指针域
    p->next=temp;
    printf("插入成功！\n");
}

//屏幕提示后，从键盘输入一个元素值，在以DLList为头指针的线性表中搜索这个元素
void search(Node *DLList)
{
    if(empty(DLList))
        return;
    Node *p;
    p=DLList->next;
    int elem,count=0;
    printf("请输入查找元素值：");
    scanf("%d",&elem);
    while(p!=NULL)
    {
        count++;
        if(p->elem==elem)
        {
            printf("该元素在链表第%d位,共比较%d次\n\n",count,count);
            display(DLList);
            return;
        }
        p=p->next;
    }
    printf("链表无此元素！共比较%d次\n",count);
}

//屏幕提示后，从键盘输入一个元素值，在以DLList为头指针的线性表中删除这个元素
//屏幕显示删除成功与否的信息
void del(Node *DLList)
{
    Node *p,*s;
    if(empty(DLList))
        return;
    int delelem,count;
    printf("请输入要删除元素值：");
    scanf("%d",&delelem);
    while(p->next!=NULL)
    {
        count++;//比较次数
        if(delelem==p->next->elem)
        {
            s=p->next;//指向删除元素
            p->next=p->next->next;//覆盖
            printf("删除成功！,共比较%d次\n",count);
            free(s);//释放内存
            return;
        }
        p=p->next;
    }
    printf("链表无此元素！共比较%d次\n",count);
}
 
//选择法排序
void selectionSort(Node *DLList)
{
    if(empty(DLList))
        return;
    Node *p,*q,*min,*temp;
    p=DLList;
    while(p->next!=NULL)
    {
        q=p->next;
        min=p;
        while(q->next!=NULL)
        {
            if(q->next->elem < min->next->elem)
                min=q;
            q=q->next;
        }
        if(min!=p)
        {
            temp=min->next;
            min->next=temp->next;//将本循环的最小值从链表删除
            temp->next=p->next;
            p->next=temp;//将本循环的最小值插入链表
        }
        p=p->next;
    }
    printf("排序完成！");
}

//应用题

//6、将链接存储线性表逆置，即最后一个结点变成第1个结点，原来倒数第2个结点变成第2个结点，如此等等。
void listReverse(Node *DLList)
{
    if(empty(DLList))
        return;
    printf("逆置前：\n");
    display(DLList);
    Node *p,*q,*s;
    p=DLList->next;//p指向第一个元素
    q=p->next;//q指向第二个元素
    p->next=NULL;//p指针域为NULL，即链表尾部
    while(q)//判断
    {
        s=q->next;//未逆置部分
        q->next=p;//逆置
        p=q;//p保存
        q=s;//提取下一个
    }
    DLList->next=p;    
    printf("\n逆置后：\n");
    display(DLList);
}

/*7、生成有序的两个单链表A和B（链表的数据和个数自定），其首结点指针分别为a和b，要求将两
个单链表合并为一个有序的单链表C，其首结点指针为c，并且合并后的单链表的数据不重复。 
*/  
void listMerge(Node *DLList)
{
    if(empty(DLList))
        return;

    Node *DLList2;//链表2
    Node *DLList3;//最终表
    Node head2,head3;//头节点
    head2.next=NULL;head3.next=NULL;
    DLList2=&head2;
    DLList3=&head3;

    Node *p,*p2,*p3;
    printf("请设置顺序表2：\n");
    init(DLList2);
    selectionSort(DLList);
    selectionSort(DLList2);
    system("cls");
    p=DLList->next;
    p2=DLList2->next;
    p3=DLList3;
    //求交集并排序
    while(p!=NULL&&p2!=NULL)
    {
        if(p->elem==p2->elem)
        {
            elemInsert(DLList3,p->elem);
            p=p->next;
            p2=p2->next;
        }
        else if(p->elem<p2->elem)
        {
            elemInsert(DLList3,p->elem);
            p=p->next;
        }
        else
        {
            elemInsert(DLList3,p2->elem);
            p2=p2->next;
        }
    }
    //找到DLList的尾指针位置
    while(p3->next!=NULL)
        p3=p3->next;
    //尾部处理
    if(p==NULL)
        p3->next=p2;
    else if(p2==NULL)
        p3->next=p;
    
    printf("排序成功！\n");
    printf("表一：\n");
    display(DLList);
    printf("表二：\n");
    display(DLList2);
    DLList->next=DLList3->next;
    free(DLList3);//释放空间
    free(DLList2);//释放空间
    printf("新表：\n");
    display(DLList);
}
//8、将一个首结点指针为a的单链表A分解成两个单链表A和B，其首结点指针分别为a和b，使得链表A中含有原链表A中序号为奇数的元素，而链表B中含有原链表A中序号为偶数的元素，且保持原来的相对顺序。
void listSplit(Node *DLList)
{
    if(empty(DLList))
        return;

    Node *DLList_odd;//奇数链表
    Node *DLList_even;//偶数链表
    Node head_odd,head_even;//头结点
    head_odd.next=NULL;
    head_even.next=NULL;
    DLList_odd=&head_odd;
    DLList_even=&head_even;

    Node *p=DLList->next;
    int serial=1;//序号
    //判断奇偶
    while(p)
    {
        if(serial%2==0)
            elemInsert(DLList_even,p->elem);
        else 
            elemInsert(DLList_odd,p->elem);
        serial++;
        p=p->next;
    }
    printf("奇数：\n");    
    display(DLList_odd);
    printf("\n");
    printf("偶数：\n");
    display(DLList_even);
    free(DLList_odd);
    free(DLList_even);
}

//判断链表是否为空，true为空
bool empty(Node *DLList)
{
    Node *p;
    p=DLList;
    if(p->next==NULL)
    {
        printf("链表为空，请初始化！\n");
        return true;
    }    
    return false;
}

//输出链表长度
int length(Node *DLList)
{
    if(empty(DLList))
        return 0;
    Node *p=DLList;
    int length=0;
    while(p->next!=NULL)
    {
        length++;
        p=p->next;
    }
    return length;
}

//插入指定元素
void elemInsert(Node *DLList,int data)
{
    int i;
    Node *p=DLList,*temp;
    while(p->next!=NULL)
        p=p->next;
    temp=new Node;
    temp->elem=data;
    temp->next=NULL;//指针域
    p->next=temp;
}
用C语言实现单链表的基本操作（附有完整代码）
m0_64365419的博客
10-22 8139
单链表的基本概念和定义以及实现过程。
数据结构创建单链表（c语言）
along_5_13的博客
08-24 4680
数据结构单链表的创建以及基本操作（c语言）
c语言单链表的实现及测试
07-20
定义了单链表的基本操作，并在主函数中测试了所有定义的操作。
C语言 关于单链表的所有操作
kawayi90hou的博客
04-08 344
目前实现的所有操作如下图所示：学数据结构半个多月了，下面是整合的对单链表组的操作，测试了一下数据，应该没问题。以下是代码：#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;math.h&gt; #include&lt;string.h&gt; #define MAXNUM 10 int cnt = 0; typedef str...
C语言--单链表的基本操作
yu1368072332的博客
09-26 547
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct Node { int value; struct Node *next; } lsNode; lsNode *InitLink(int count) { lsNode *head = (lsNode*)malloc(sizeof(lsNode)); /...
数据结构-单链表基本操作——C语言
weixin_50490968的博客
04-24 3371
一、按位插入（带头结点）ListInsert(&l,i,e) Tips：(此时是 i=1 的情况，插在表头，不执行while循环 ) //在第i个位置插入元素 e （带头结点） typedef struct LNode{ //单链表结构定义 ElemType data; //存放数据域 struct LNode *next; //指针域 }LNode,*LinkList; { /* data */ }; boo
单链表的基本操作(C语言+图解分析)
Curz酥的博客
08-23 1903
纯C语言，代码均可直接运行，读者可自行调试。
单链表(C语言)
09-29
C语言的单链表，有存储、查询、删除等功能，代码简单，有注释。适合初学者
教师管理系统（C语言）（单链表）
07-03
1、实现软件：Dev-C++ 2、详细的测试页面可见我《资源》专栏下的《C语言系统资源测试》。 3、适合新手下载学习。 4、基于C语言的单链表实现。 5、代码共461行 6、注释多，排版有序
单链表的c语言实现
07-21
单链表的c语言实现，经过编译连接运行正确，结构简单易懂
【数据结构】二、单链表的基本操作(C语言)
lieam的博客
12-22 8153
【数据结构】二、单链表的基本操作(C语言)
c语言单链表注释,【C语言】单链表的反转
weixin_42522275的博客
05-18 151
假设单链表的数据结构定义如下：typedefstructLNode{intdata;structLNode*next;}LNode, *LinkedList;并且这个单链表有一个头指针list指向第一个结点，最后一个结点指向NULL，很容易理解。最容易想到的第一种方法就是重新建立一个单链表newList，每次将list中的第一个结点放到newList后面。注释比较详细，所以就不具体说了，...
C语言菜单构建（动态链表的创建并运用菜单实现选择功能）
最新发布
ddddas_a的博客
01-07 1394
printf("第%d个节点的数据是：字符数据为%s 数字数据为%d\n",n, p->name,p->data);//调用文件数据保存函数。NOD* getfromfile(NOD* head, char* filename)//文件读取函数。void savetofile(NOD* head, char* filename)//文件保存函数。if (p1->name[0]=='\n')//如果字符串为空，结束链表创建。
C语言 使用链表创建多级菜单
2301_77659064的博客
12-06 5151
本代码只是示例，如果你需要多级菜单，只需更改/* 1.在此填写要运行的函数 */；/* 2.在此多级菜单 */；分隔符内的函数，后面也会给出二级菜单和三级菜单的例程，你可以对比出差别，创建多级菜单还是很简单直观的。接下来是一级菜单，注释已经足够详细，感兴趣的朋友可以仔细看看，重点在于MenuItem结构体中的。
【C/C++】链表操作
LittleWheat的博客
02-13 378
功能菜单： ****************************************************************** ** 链表操作菜单 ** ** 1、创建链表并输入结点数据(包含num和goal，num==0结束) ** ** 2、输...
数据结构：单链表的基本操作，含菜单（C/C++）
weixin_46601559的博客
11-13 2129
C语言： #include <stdio.h> #include <stdlib.h> #define ERROR 1 #define OK 0 /* 单链表结点定义 */ typedef struct LNode { int data; //data中存放结点数据域（默认是int型） struct LNode *next; //指向后继结点的指针 }LNode; //操作函数的声明 LNode *HeadCreateList(int len);
C语言：功能齐全的链表代码
qq_53452010的博客
03-28 3101
此链表可以实现创建，输入，序号查找，数值查找，插入，删除，输出等功能 代码： #include<stdio.h> #include<stdlib.h> typedef struct linklist{ int data; struct linklist *next; }*LinkList; void Menu(void); int Length(LinkList head); void CreateList(LinkList *head); void IntoList(L
王道408 数据结构之 给定两个单链表，编写算法找出两个链表的公共节点
qq_40066238的博客
07-14 3083
基本思想 所谓找出两个单链表的公共节点，就是将链表相交的部分的第一个节点找出来，此节点后的所有节点都是公共节点。 如图，链表A的5个节点分别为a1,a2,c1,c2,c3，链表B的6个节点分别为b1,b2,b3,c1,c2,c3（注意此处没有考虑虚拟头节点的存在） 显然，从c1开始它们便不可能再出现分支，我们的算法也应当返回c1的地址。 当A、B的长度相同时，找出c1非常简单，只要我们设置两个指针curA, curB同时指向A、B的第一个数据节点，并依次比较两个指针指向的地址值是否相同，最终一定会在c1处
数据结构实验:创建并合并两个有序单链表
爱学习的cyh
04-14 1584
#include<stdio.h> #include<iostream> using namespace std; #include<windows.h> #include<malloc.h> #include<conio.h> #define OK 1 #define ERROR 0 typedef int elemtype; typ...
C语言单链表代码实现及注释详解
以上就是单链表在C语言中的基础知识点和常见的操作实现。由于压缩包子文件的文件名称列表中没有提供具体的文件名，我们无法针对具体的代码文件进行分析。不过，上述信息可以作为理解和实现单链表代码的参考。在实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值