链表的基本操作

最新推荐文章于 2023-10-25 20:22:48 发布
最新推荐文章于 2023-10-25 20:22:48 发布
阅读量505 收藏
点赞数
分类专栏： 计算机类 文章标签： 计算机 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Ohahah/article/details/88669388
版权

链表

（以下内容均为单向链表）
链表是用链节指针链在一起的自引用结构变量（称为结点）的线性集合，是线性表的一种存储结构。假设我们想随心所欲创建一个结构，输入多少次数据他就有多大，可以说是游刃有余。相比数组和动态分配，这两者其实都有缺陷：数组，比如一个字符串数组，要存储书名，在我不知道所有名字到底多长时，字符串长度只能设置为最长的哪那个，浪费内存；动态分配内存，恐怕就是不断在malloc和realloc里，写起来难以理解不方便。所以介绍链表思想。
链表的性质：
（1）headPtr──指向链表首元结点的指针变量。（有的时候会有）
（2）每个结点由2个域组成：
数据域──存储结点本身的信息。
指针域──存储指向后继结点的指针(针对单向链表)。
（3）尾结点的指针域置为NULL(用反斜杠表示)，作为链表结束的标志。

链表的特点：
1. 链表是一种存储结构，用于存放线性表；
2. 链表的结点是根据需要调用动态内存分配函数进行分配的，因此链表可随需要伸长缩短，在要存储的数据个数未知的情况下节省内存；
3. 链表的结点在逻辑上是连续的，但是各结点的内存通常是不连续的，因此不能立即被访问到，只能从首元结点开始逐结点访问。

如何访问链表中的结点：
由于链表中结点的内存是动态分配的，无法通过名称去访问，因此只能通过结点的地址去访问。

某结点的地址记录在其前驱结点的地址域里，因此要想访问第n个结点，必须先得访问第n-1个结点，读取该结点的地址域；而要想访问第n-1个结点，必须先得访问第n-2个结点；以此类推，一直推到访问第1个结点。而第1个结点是由指针headPtr指向的，因此能访问第1个结点，从而也就能访问第2个结点，第3个结点……从这一点上看，链表的访问效率比较低。

链表与数组特点对比：
数组的优点：
数组中的元素在内存中是连续存放的，能根据数组的首地址计算出各数组元素的内存地址，所以可以直接用下标访问到数组元素；而链表中的元素在内存中通常是不连续存放的，因此不能被立即访问到。

链表的优点：
1、可伸缩性：数组一旦在内存分配空间之后，大小就不能改变；而链表是动态的，在需要的时候可以增加或删减结点；数组的空间可能很快就用完，而链表只有在系统没有足够的内存满足动态分配存储空间的请求时 才会达到全满的状态；
2、插入和删除操作：数组的插入和删除涉及到移动元素的操作，因此比较费时；而链表的插入和删除比较简单；

对链表的基本操作：
创建链表、检索（查找）结点、插入、删除结点和修改结点等。
（1）创建链表是指：从无到有地建立起一个链表，即往空链表中依次插入若干结点，并保持结点之间的前驱和后继关系。
（2）检索操作是指：按给定的结点索引号或检索条件，查找某个结点。
（3）插入操作是指：在结点ki-1与ki之间插入一个新的结点k 。
（4）删除操作是指：删除结点ki，使线性表的长度减1。
下面我们依次看一下这些操作。

  1. 创建：
    为了统一描述，先建立好结构及其代称方便之后描述：
typedef struct listnode list;
typedef list * listPtr;
struct listnode{
	int data;
	list *next;
};

【注】：创建的两种方法：
1.返回头指针值；listPtr create(){…}
2.执行对头指针地址值的改写；void create(listPtr *headPtr){…}

listPtr create()                        				//创建并返回头指针
{
    int num;
    list *headPtr=NULL,*currentPtr=NULL,*lastPtr=NULL;
    scanf("%d",&num);									//以输入数据为-1结束
    while(num!=-1){
        currentPtr=(listPtr)malloc(sizeof(list));		//给current分配新的空间，使其进一步变为一个存储信息的节点
        if(currentPtr!=NULL)
            currentPtr->data=num;
        if(headPtr==NULL)								//如果头指针为空，那么把current给他，并用lastPtr记录current的当前位置
        {
            headPtr=currentPtr;
            lastPtr=currentPtr;
        }
        else{											//否则，把上一个lastPtr的next指针和当前的节点连起来，然后继续用lastPtr记录current位置
            lastPtr->next=currentPtr;
            lastPtr=currentPtr;
        }
        scanf("%d",&num);
    }
    lastPtr->next=NULL;									//一定记得把链表尾节点的next指向空NULL
    return headPtr;
}

如果实在无法理解创建过程，可以这样想：比如lastPtr这个辅助指针，
lastPtr->nextPtr=currentPtr;
lastPtr=currentPtr;
这两句话其实是说：我之前构造的空间，它的表尾与下一个新空间进行了联通，那么现在就实现了链接，我需要让lastPtr继续服务，就必须让它继续充当“最后一个空间的牌面”，因而把新空间的地址交付给他，这一切完成的只是“利用名字找对地址，进而使地址名下的空间实现连通”的过程而已，一个节点的地址可以用多个名字表示的。

  1. 打印：
    顺序遍历，不为空就打印出来
void print(listPtr headPtr)                    //打印
{
    listPtr current=NULL;
    if(headPtr==NULL)
        printf("None\n");
    else{
        current=(listPtr)malloc(sizeof(list));
        current=headPtr;
        while(current!=NULL){
            printf("%d\n",current->data);
            current=current->next;
        }
    }
}
  1. 释放：
    创建时malloc申请地空间的常规操作
    使用辅助节点current记录地址位置以防头结点信息丢失
void destroy(listPtr headPtr){
	list *current=NULL;
	while(headPtr!=NULL){
		current=headPtr;
		headPtr=headPtr->next;
		free(current);
	}
}
  1. 插入：
    基本思路就是，从头开始往后遍历，设置current，用number进行遍历检索时，同时记录current前面一个节点prePtr，当number到达适合的位置时，就在prePtr和current节点之间插入新节点（当然，前提是这个链表本来就是升序的）
listPtr insert(listPtr headPtr)            //插入
{
    int num;
    list *prePtr=NULL,*newPtr=NULL,*current;
    scanf("%d",&num);
    newPtr=(listPtr)malloc(sizeof(list));
    newPtr->data=num;
    current=headPtr;
    while(current!=NULL&&num>current->data){
        prePtr=current;
        current=current->next;
    }
    if(prePtr==NULL){
        newPtr->next=current;
        headPtr=newPtr;
    }
    else if(current==NULL){
        current->next=newPtr;
        newPtr->next=NULL;
    }
    else{
        prePtr->next=newPtr;
        newPtr->next=current;
    }
    return headPtr;
}
  1. 删除：
    就是遍历，找适合条件的节点，然后把其前节点prePtr和其本身后节点next连起来
listPtr delete(listPtr headPtr)                //删除
{
    int num;
    scanf("%d",&num);
    list *prePtr=NULL,*current;
    current=headPtr;
    while(current!=NULL&&num!=current->data){
        prePtr=current;
        current=current->next;
    }
    if(prePtr==NULL){
        headPtr=headPtr->next;
    }
    else if(current==NULL){
        printf("You ass fool,there's no such kind of node.\n");
    }
    else{
        prePtr->next=current->next;
    }
    return headPtr;
}

链表的应用：

  1. 对链表内排序：升序链表的创建
    其实道理很简单，在创建过程中，没开辟一个新空间节点current，就把current插入到原链表中去，就实现了升序创建。
listPtr paixu(){
    int num;
    scanf("%d",&num);
    list *headPtr=NULL;
    while(num!=-1){
        headPtr=insert(headPtr,num);
        scanf("%d",&num);
    }
    return headPtr;
}


listPtr insert(listPtr headPtr,int num){
    int b=0;
    list *prePtr=NULL,*current,*newPtr=NULL;
    newPtr=(listPtr)malloc(sizeof(list));
    newPtr->data=num;
    if(headPtr==NULL){
        headPtr=newPtr;
        headPtr->next=NULL;            //否则程序在第二次进行插入时会卡死
    }
    else{
        current=headPtr;
        while(current!=NULL&&num>current->data){/*current!=NULL这句话要先写，
        C语言只要前者不行就不判断后者，这样，当current是NULL时不会造成
        “无法访问任何东西”，这被称为“逻辑短路”，不要越界访问！*/
            prePtr=current;
            current=current->next;
        }        
        if(prePtr==NULL){
            newPtr->next=current;
            headPtr=newPtr;
        }
        else if(current==NULL){
            prePtr->next=newPtr;
            newPtr->next=NULL;
        }
        else{
            prePtr->next=newPtr;
            newPtr->next=current;
        }
    }
    return headPtr;
}

我们也可以，冒泡排序，基本思路就是，记录要被交换的节点A的prePtr和节点B的prePtr和节点B自己的位置，三节点交换。这里先用辅助量count（链表元素个数）方便操作

listPtr order(listPtr headPtr,int count){
    int i,j;
    list *prePtr1=NULL,*prePtr2=NULL,*current=NULL;
    if(count==1)
        return headPtr;											//直接判断特殊情况，节省时间先
    else{
        for(i=count;i>0;i--){
            prePtr1=headPtr;
            prePtr2=prePtr1->next;
            current=prePtr2->next;
            for(j=0;j<i&&prePtr2->next!=NULL;j++){
                if(j==0&&prePtr1->data > prePtr2->data){		//如果判断的是第一、第二个节点且要交换
                    prePtr1->next=prePtr2->next;				//三节点交换法，不懂可以画箭头图分析
                    prePtr2->next=prePtr1;
                    headPtr=prePtr2;
                    prePtr1=headPtr;
                    prePtr2=prePtr1->next;
                    current=prePtr2->next;						//保持三个节点相对顺序，这样可以一直判断下去
                }
                if(j>0&&prePtr2->data > current->data){
                    prePtr1->next=current;
                    prePtr2->next=current->next;
                    current->next=prePtr2;
                }
                if(j>0){
                    prePtr1=prePtr1->next;
                    prePtr2=prePtr1->next;
                    current=prePtr2->next;
                }
            }
        }
    }
    return headPtr;
}
  1. 链表节点段的交换问题：
    上文只涉及单节点交换，接下来我们完成从[s1]，[t1]到[s2]，[t2]的片段交换。
    坑：1.如果s1=t1等怎么处理？我的算法由于记录了整8个节点所以相对安全
    2.如果t1=s2-1？s1=0?{
    情况一：t1=s2-1如图过程：在这里插入图片描述 在这里插入图片描述
    情况二：t1!=s2-1如图：在这里插入图片描述在这里插入图片描述
listPtr exchange(listPtr headPtr,int s1,int t1,int s2,int t2)
{
    list *prePtr1=NULL,*prePtr2=NULL,*leftPtr;
    list *preTemp1=NULL,*lastTemp1,*preTemp2=NULL,*lastTemp2;
    prePtr1 =find(headPtr,s1-1);        preTemp1 =find(headPtr,s1);
    lastTemp1=find(headPtr,t1);
    prePtr2 =find(headPtr,s2-1);        preTemp2 =find(headPtr,s2);
    lastTemp2=find(headPtr,t2);
    if(s2!=t1+1){
        leftPtr=lastTemp1->next;
        lastTemp1->next=lastTemp2->next;
        if(s1>1)
            prePtr1->next=preTemp2;
        lastTemp2->next=leftPtr;
        prePtr2->next=preTemp1;
    }
    else{
        if(s1>1)
            prePtr1->next=preTemp2;
        lastTemp1->next=lastTemp2->next;
        lastTemp2->next=preTemp1;
    }
    if(s1!=1)
        return headPtr;
    else
        return preTemp2;
}
listPtr find(listPtr headPtr,int where)				//找到第where个节点并返回其地址位置
{
    int count=0;
    list *current=NULL,*prePtr=NULL;
    current=headPtr;
    if(where==0)prePtr=headPtr;
    while(count<where&&current!=NULL){
        prePtr=current;
        current=current->next;
        count++;
    }
    return prePtr;
}

以下为双向节点链表（虽然不完全是）：值得注意的是，对某些节点定义好内部pre指针的方向，将有助于大大简化操作

typedef struct node{
    int value;
    struct node *next;
    struct node *pre;
}Node;								//以及：不再需要find函数！
Node* exchange(Node *head,int s1,int t1,int s2,int t2){
    Node *ps1,*pt1,*ps2,*pt2;
    Node *p = head->next;
    for(int i = 1;p;p = p->next,i++){
        if(i==s1) ps1 = p;
        if(i==t1) pt1 = p;
        if(i==s2) ps2 = p;
        if(i==t2) pt2 = p;
    }
    Node *temp1 = ps1,*temp2 = ps2;
    ps1->pre->next = temp2;
    temp2->pre->next = temp1;
    Node *temp3 = pt1->next,*temp4 = pt2->next;
    pt2->next = temp3;
    pt1->next = temp4;				 //    三变量法交换
    return head;
}
其余略......
  1. 逆序输出问题：
    方法一：在创建的时候，每次制造完新节点，都让他接到head前面，再把head调到首位，循环此操作。
listPtr create(){
    list *headPtr,*current;
    int num;
    scanf("%d",&num);
    while(num!=-1){
        current=(listPtr)malloc(sizeof(list));
        current->data=num;
        if(headPtr==NULL){
            headPtr=current;
            headPtr->next=NULL;
        }
        else{
            current->next=headPtr;
            headPtr=current;
        }
        scanf("%d",&num);
    }
    return headPtr;
}

方法二：拆解，重构。从头开始，依次拆解一个节点的next指向，并指向新节点：其previous one。 就像是不断把head挪到新位置在这里插入图片描述

listPtr reverse(listPtr headPtr){
    list *prePtr,*current,*frontPtr;
    if(headPtr==NULL)
        return NULL;
    else{
        prePtr=headPtr;
        current=prePtr->next;
        headPtr->next=NULL;        //注意！因为此时head的位置是作为最终链表的尾节点
        while(current!=NULL){
            frontPtr=current->next;
            current->next=prePtr;
            prePtr=current;
            current=frontPtr;
        }
    }
    return prePtr;                   //别传错了，head此时只是尾节点
}

方法三：递归，不到最后一项不打印。先函数，后打印

void print(listPtr headPtr){
    list *current;
    current=headPtr;
    if(current!=NULL){
        print(current->next);
        printf("%d",headPtr->data);
    }
}
  1. 链表归并问题：
    思路：明确我想把head2插到head1里面去，实现过程：首先，针对head2的首数，看一看它在head1里能找到哪个夹缝塞进去，即对head1遍历，head2->data为标尺确定prePtr1和current1 然后看看从head2开始能有几个节点能进入夹缝，即对head2遍历，current1->data为标尺卡出prePtr2和current2，确定后，插入后，把head2换到current2位置，继续搜索插入。
    有关leftPtr：这是一个针对head的辅助变量，因为我们发现两个head都有可能被改写，而head2的改写可能是“丢失性的”，leftPtr能帮助我们控制好head2的地址得以保留。
listPtr merge(listPtr headPtr1,listPtr headPtr2){
    list *prePtr1,*prePtr2,*current1,*current2,*leftPtr;
    while(headPtr2!=NULL){
        leftPtr=headPtr2;
        prePtr1=NULL;
        prePtr2=NULL;
        current1=NULL;
        current2=NULL;
        find(headPtr1,leftPtr->data,&prePtr1,&current1);
        if(current1==NULL){
            prePtr1->next=leftPtr;
            headPtr2=NULL;
        }
        else{
            find(headPtr2,current1->data,&prePtr2,&current2);
            if(current1==headPtr1){
                prePtr2->next=headPtr1;
                headPtr1=leftPtr;
            }
            else{
                prePtr1->next=leftPtr;
                prePtr2->next=current1;
                headPtr2=current2;
            }
        }
    }
    return headPtr1;
}

void find(listPtr headPtr,int num,listPtr *prePtr,listPtr *current){	//相互查询找位子
    list *currentTemp,*preTemp;
    currentTemp=headPtr;
    preTemp=NULL;
    while(currentTemp!=NULL&&currentTemp->data<=num){
        preTemp=currentTemp;
        currentTemp=currentTemp->next;
    }
    *prePtr=preTemp;
    *current=currentTemp;
}
  1. 约瑟夫环问题：
    在一个“循环链表”里（即lastPtr->next=headPtr），每次让prePtr处于“零位”，那么在每次循环开始，我让current指针开始向后移位，并结合count递增，就能模拟“从一开始依次报数”了
    首先，第一次循环current，使current到达尾节点。第二次循环，初，用prePtr记录尾节点“零位”，current后移到达1，报数开始，如果可除名，除，利用prePtr，实现新“零位”。
    比如猴子选大王
listPtr create(int n){								//创建有n个节点的链表
    list *headPtr=NULL,*current=NULL,*lastPtr=NULL;
    int i;
    for(i=1;i<=n;i++){
        current=(listPtr)malloc(sizeof(list));
        current->data=i;
        if(headPtr==NULL){
            headPtr=current;
            lastPtr=current;
            headPtr->next=NULL;
        }
        else{
            lastPtr->next=current;
            lastPtr=current;
        }
    }
    lastPtr->next=headPtr;
    return headPtr;
}

listPtr choose(listPtr headPtr,int n,int m){
    list *prePtr,*current,*lastPtr;
    int count=0;
    current=headPtr;
    while(current->next!=headPtr)
        current=current->next;                    //找到最后一个区
    while(current->next!=current){
        prePtr=current;
        current=current->next;
        count++;
        if(count%m==0){
            prePtr->next=current->next;
            printf("It's '%d!\n",current->data);
            free(current);
            current=prePtr;
        }
    }
    printf("Our king:%d!!!\n",current->data);
    free(current);									
}
//因为是循环链表，除非告知n，要不释放起来比较麻烦，而边创建新链接边释放就方便得多，也符合“出局”要求

总之，链表的思想精髓在于 交换位置 而非 交换内容（当然交换内容也行，但锻炼不了思维方式），在某些对数据结构要求高的方面，链表是极其基础而重要的工具。

怡宝的代言人连高波
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表基本操作（详解）
Czc1357618897的博客
11-30 1万+
链表的基本操作 这里写目录标题链表的基本操作一：单链表的基础知识二：单链表的建立头插法尾插法三：单链表的遍历四：单链表结点数目判断五：单链表的插入链表头插入任意结点插入链表尾部插入六：单链表的删除七 ：单链表的查询 一：单链表的基础知识 为什么需要链表？ 我们在使用数组存放数据是非常方便，但是由于数组的长度是固定的，所以当存储不同的元素数量时，就很容易出现问题。如果向数组中添加的数量大于数组大小时候，信息无法完全被保存。所以我们需要另一种存储方式来存储数据，其中存储的元素的个数不受限制。这种存储方式就是链
【数据结构-链表】链表的基本操作
Mount256的博客
10-26 1782
【数据结构-链表】链表的基本操作
数据结构实验一(2) 链表的基本操作
流苏的博客
05-21 2233
数据结构实验一(2) 链表的基本操作
链表基本操作
12-08
链表基本操作,是关于代码的使用，链表的基本操作，设计等操作
链表基本操作源码
12-28
以下是对链表基本操作的详细讲解： 1. **链表的定义** 链表由一系列节点组成，每个节点包含数据和指向下一个节点的指针。对于双向链表，每个节点还包含一个指向前一个节点的指针。在C语言中，链表节点（或称为结点...
实验二 链表基本操作的实现
12-18
在这个实验“链表基本操作的实现”中，我们将深入理解链表的概念，学习如何创建、插入、删除节点，以及进行其他基本操作。 链表不同于数组，它不连续存储元素，而是通过节点间的指针链接。每个节点包含两部分：数据...
lianbiao.rar_链表基本操作_链表操作
09-24
接下来，我们将深入探讨链表的基本操作，包括链表的创建、删除以及统计链表长度。 1. **链表的创建** 创建链表首先要定义节点结构，一般包括数据域（存储数据）和指针域（指向下一个节点）。例如，我们可以定义一...
C语言实现链表基本操作
10-09
在这个主题中，我们将深入探讨如何用C语言实现链表的基本操作，包括创建链表、插入元素、删除元素以及遍历链表。 首先，链表不同于数组，数组中的元素在内存中是连续存储的，而链表中的节点通过指针链接，可以分散...
链表的基本操作--c语言
qq_51533157的博客
06-25 5950
链表是数据结构中一种最基本的数据结构，它是用链式存储结构实现的线性表。它较顺序表而言在插入和删除时不必移动其后的元素。现在给你一些整数，然后会频繁地插入和删除其中的某些元素，会在其中某些时候让你查找某个元素或者输出当前链表中所有的元素。 下面给你基本的算法描述： 图1：链表类型的定义以及获得链表元素的算法描述 图2：链表的插入算法描述 图3：链表的删除算法描述 图4：链表的创建算法描述 输入 输入数据只有一组，第一行有n+1个整数，第一个整数是这行余下的整数数目n，后面是n个整
【数据结构】链表的十三种操作
最新发布
littlegengjie的博客
10-25 1325
双向链表链表的初始化、销毁、清空、链表长度、求双向链表前驱、后继、遍历链表，头插法输入链表、双向链表逆序存放。
C语言单链表的基本操作总结（增删改查）
热门推荐
.
01-27 15万+
1.链表概述   链表是一种常见的数据结构。它与常见的数组是不同的，使用数组时先要指定数组包含元素的个数，即为数组的长度，但是如果向这个数组中加入的元素超过了数组的大小时，便不能将内容全部保存。   链表这种存储方式，其元素个数是不受限定的，当进行添加元素的时候存储的个数就会随之改变。   链表一般有两种形式，有空头链表和无空头链表。   在链表中有一个头指针变量，这个指针变量保存一个地址，...
【数据结构】链表的基本操作
m0_53171456的博客
03-11 8299
规划 /* 链表的基本操作 */ #include<iostream> #include<algorithm> #define ElemType int using namespace std; typedef struct LNode{ ElemType data; //数据域 LNode *next; //指针域 } *LinkList; //链表的初始化 void IniteList(LinkList &L){ L = new LNode; //创建头结点
数据结构之链表的基本操作
qq_62617615的博客
03-15 681
指针域的next类型是struct node*(指向struct node类型的指针类型)，因为next要只想下一个结点（struct node 类型）在上述程序段中，有意的对代码进行简化，再用定义变量（即静态内存分配）的方式创建链表结点。访问连表示总是从第一个开始顺序访问，因此需要定义一个专门的指针，用于指向链表的第一个结点，并称之为头指针。例1，创建一个包含3个结点的简单链表，每个节点包含一个整形数据成员和一个指针成员。然后，依次在链表结点的数据域中存入数据，并通过指针域将链表结点连接起来。
完全小白篇-使用Python爬取网络小说
Mr_Ohahah的博客
07-26 2万+
完全小白篇-使用Python爬取网络小说找一个你要爬取的小说分析网页一、网页的展示方式需要用到的库文件向网站发送请求正则提取跳转的逻辑后续处理保存信息进入docx文件新的问题：超时重传 找一个你要爬取的小说 作为python小白，这篇博客仅作为我的一个学习记录。 本篇我就拿一个实际案例来做吧，短短50行代码调试了一晚上，爬虫还得继续好好学啊！拿最近很火的《元龙》举例。 （采用读书网的资源） 分析网页 一、网页的展示方式 打开最开始的那章，按F12看一下网页代码，首先需要注意的地方无外乎两点： 从目录的网
C语言链表基本操作代码
04-23
好的，以下是C语言链表基本操作的代码示例： ```c #include #include struct Node { int data; struct Node *next; }; struct Node* create_node(int data) { struct Node* new_node = (struct Node*) ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值