01链表操作

最新推荐文章于 2025-07-22 21:01:39 发布
最新推荐文章于 2025-07-22 21:01:39 发布
阅读量242 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 头歌代码 文章标签： 链表 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dust_as_light/article/details/144893605

第1关：顺序构建线性表

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

// 定义结点结构
struct node
{
    int data;  // 数据域
    struct node * next;  //指针域,指向下一个结点
};


node *insertTail(node *h, int a[],int n)
{
    // 请在此添加代码，补全函数insertTail
    //链表带头结点
    /********** Begin *********/
   node *newhead=h;
   for(int i=0;i<n;i++)
   {
       node *newnode=(node*)malloc(sizeof(node));
       newnode->data=a[i];
       newnode->next=NULL;
       newhead->next=newnode;
       newhead=newnode;
   }
   return h;
    /********** End **********/
}


// 函数delList：删除链表，释放空间
// 参数：h-链表头指针
void delList(node *h)
{
    node *p=h->next;  // 指针p指向头结点，第一个要删除的结点
    while(p)  // 这个结点是存在的
    {
        h = h->next;  // 头指针h指向下一个结点（下一个结点的地址存在当前结点的指针域中，即h->next中
        delete p;  // 删除p指向的结点
        p = h;  // p指向当前的头结点，即下一个要删除的结点
    }
}
// 函数printList：输出链表，每个数据之间用一个空格隔开
// 参数：h-链表头指针
void printList(node *h)
{
    printf("List:");
    node* p = h->next;
    while(p)
    {// h为真，即h指向的结点存在，则输出该结点的数据
        printf(" %d",p->data);  // 输出结点数据
        p=p->next;  // 将该结点的指针域赋值给h，h就指向了下一个结点
    }
    printf("\n"); // 输出换行符
}
int main()
{
    int n,i;
    node *t;
    node *head=(node *)malloc(sizeof(node));
    head->next = NULL;
    // 输入结点数
    scanf("%d",&n);
    int a[100];
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);  // 输入结点数据
    }

    head = insertTail(head,a,n);
    // 输出链表
    printList(head);
    // 删除结点，释放空间
    //delList(head);

    return 0;
}

第2关：逆序构建线性表


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

// 定义结点结构
struct node
{
    int data;  // 数据域
    node * next;  //指针域,指向下一个结点
};



node * insertHead(node *h, int a[],int n)
{
    // 请在此添加代码，补全函数insertHead
    //有头结点
    /********** Begin *********/
  node* newhead=h;
  for(int i=0;i<n;i++)
  {
      node* newnode=(node*)malloc(sizeof(node));
      newnode->data=a[i];
      newnode->next=newhead->next;
      newhead->next=newnode;
  }
return h;

    /********** End **********/
}

// 函数delList：删除链表，释放空间
// 参数：h-链表头指针
void delList(node *h)
{
    node *p=h->next;  // 指针p指向头结点，第一个要删除的结点
    while(p)  // 这个结点是存在的
    {
        h = h->next;  // 头指针h指向下一个结点（下一个结点的地址存在当前结点的指针域中，即h->next中
        delete p;  // 删除p指向的结点
        p = h;  // p指向当前的头结点，即下一个要删除的结点
    }
}
// 函数printList：输出链表，每个数据之间用一个空格隔开
// 参数：h-链表头指针
void printList(node *h)
{
    printf("List:");
    node* p = h->next;
    while(p)
    {// h为真，即h指向的结点存在，则输出该结点的数据
        printf(" %d",p->data);  // 输出结点数据
        p=p->next;  // 将该结点的指针域赋值给h，h就指向了下一个结点
    }
    printf("\n"); // 输出换行符
}
int main()
{
    int n,i;
    node *t;
    node *head=(node *)malloc(sizeof(node));
    head->next = NULL;
    // 输入结点数
    scanf("%d",&n);
    int a[n];
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);  // 输入结点数据
    }
    head = insertHead(head, a,n);

    // 输出链表
    printList(head);
    // 删除结点，释放空间
    //delList(head);

    return 0;
}

第3关：查找元素


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

// 定义结点结构
struct node
{
    int data;  // 数据域
    node * next;  //指针域,指向下一个结点
};



// 函数insertHead：链表头部插入
// 参数：h-链表头指针，带头结点链表，a[]-要输入的结点的值，n-要输入结点个数
// 返回值：插入后的链表
node * insertHead(node *h, int a[],int n)
{
    // 请在此添加代码，补全函数insertHead
    //有头结点
    /********** Begin *********/
   node* newhead=h;
  for(int i=0;i<n;i++)
  {
      node* newnode=(node*)malloc(sizeof(node));
      newnode->data=a[i];
      newnode->next=newhead->next;
      newhead->next=newnode;
  }
return h;
    /********** End **********/
}

// 函数search：在链表中查找包含数据num的第一个结点
// 参数：h-链表头指针，num-要查找的数据, local-为要找到的结点的位置，从1开始,未找到，local为0；
// 返回值：找到了返回该结点的地址，否则返回NULL
node * search(node * h, int num,int *local)
{
    // 请在此添加代码，补全函数search
    /********** Begin *********/
    *local=1;
    node *newhead=h->next;
    while(newhead)
    {
        if(newhead->data==num)
        {
             return newhead;
        }
        (*local)++;
        newhead=newhead->next;
    }
    *local=0;
    return NULL;
    /********** End **********/
}





// 函数delList：删除链表，释放空间
// 参数：h-链表头指针
void delList(node *h)
{
    node *p=h->next;  // 指针p指向头结点，第一个要删除的结点
    while(p)  // 这个结点是存在的
    {
        h = h->next;  // 头指针h指向下一个结点（下一个结点的地址存在当前结点的指针域中，即h->next中
        delete p;  // 删除p指向的结点
        p = h;  // p指向当前的头结点，即下一个要删除的结点
    }
}
// 函数printList：输出链表，每个数据之间用一个空格隔开
// 参数：h-链表头指针
void printList(node *h)
{
    printf("List:");
    node *p=NULL;
    if(h)
    {
           p = h->next;
    }
  
    while(p)
    {// h为真，即h指向的结点存在，则输出该结点的数据
        printf(" %d",p->data);  // 输出结点数据
        p=p->next;  // 将该结点的指针域赋值给h，h就指向了下一个结点
    }
    printf("\n"); // 输出换行符
}
int main()
{
    int n,i,local,num;
    node *t;
    node *head=(node *)malloc(sizeof(node));
    head->next = NULL;
    // 输入结点数
    scanf("%d",&n);
    int a[n];
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);  // 输入结点数据
    }
    head = insertHead(head, a,n);
   

    //输入要查找的数

    scanf("%d",&num);
    //在链表中查找num
    node *np = search(head,num,&local);

 
    printf("Location: %d\n",local);
    //输出从np开始的后半截链表（如果np为NULL，则输出空链表）
    // 输出链表
    printList(np);
    // 删除结点，释放空间
   // delList(head);

    return 0;
}

第4关：删除指定位置的结点


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

// 定义结点结构
struct node
{
    int data;  // 数据域
    node * next;  //指针域,指向下一个结点
};

// 函数insertSort：链表排序插入
// 参数：h-链表头指针，带头结点链表，a[]-要输入的结点的值，n-要输入结点个数
// 返回值：插入后的链表
node *insertTail(node *h, int a[],int n)
{
    // 请在此添加代码，补全函数insertTail
    //链表有头结点
    /********** Begin *********/
  node *newhead=h;
   for(int i=0;i<n;i++)
   {
       node *newnode=(node*)malloc(sizeof(node));
       newnode->data=a[i];
       newnode->next=NULL;
       newhead->next=newnode;
       newhead=newnode;
   }
   return h;
    /********** End **********/
}





// 函数delAt：删除链表中序号为i的结点，如果i是非法序号则不做操作
// 参数：h-链表头指针，i-要删除结点的序号
// 返回值：删除结束后链表
node * delAt(node * h, int i)
{
    // 请在此添加代码，补全函数delAt
    /********** Begin *********/
    node* pur=h->next;
    node* pre=h;
    int k=0;
    while(k!=i)
    {
        if(pur->next==NULL)
        return h;
        pre=pre->next;
        pur=pur->next;
        k++;
    }
    pre->next=pur->next;
    return h;


    /********** End **********/
}



// 函数delList：删除链表，释放空间
// 参数：h-链表头指针
void delList(node *h)
{
    node *p=h->next;  // 指针p指向头结点，第一个要删除的结点
    while(p)  // 这个结点是存在的
    {
        h = h->next;  // 头指针h指向下一个结点（下一个结点的地址存在当前结点的指针域中，即h->next中
        delete p;  // 删除p指向的结点
        p = h;  // p指向当前的头结点，即下一个要删除的结点
    }
}
// 函数printList：输出链表，每个数据之间用一个空格隔开
// 参数：h-链表头指针
void printList(node *h)
{
    printf("List:");
    node* p = h->next;
    while(p)
    {// h为真，即h指向的结点存在，则输出该结点的数据
        printf(" %d",p->data);  // 输出结点数据
        p=p->next;  // 将该结点的指针域赋值给h，h就指向了下一个结点
    }
    printf("\n"); // 输出换行符
}
int main()
{
    int n,i,local,num;
    node *t;
    node *head=(node *)malloc(sizeof(node));
    head->next = NULL;
    // 输入结点数
    scanf("%d",&n);
    int a[n];
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);  // 输入结点数据
    }
    
    head = insertTail(head,a,n);

    //输入要查找的数



    scanf("%d",&i);
    node *np = delAt(head,i);


    // 输出链表
    printList(np);
    // 删除结点，释放空间
    //delList(head);

    return 0;
}

第5关：删除包含特定数据的结点


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

// 定义结点结构
struct node
{
    int data;  // 数据域
    node * next;  //指针域,指向下一个结点
};

// 函数insertSort：链表排序插入
// 参数：h-链表头指针，带头结点链表，a[]-要输入的结点的值，n-要输入结点个数
// 返回值：插入后的链表
node *insertTail(node *h, int a[],int n)
{
    // 请在此添加代码，补全函数insertTail
    //链表有头结点
    /********** Begin *********/
    node *newhead=h;
   for(int i=0;i<n;i++)
   {
       node *newnode=(node*)malloc(sizeof(node));
       newnode->data=a[i];
       newnode->next=NULL;
       newhead->next=newnode;
       newhead=newnode;
   }
   return h;
  
    /********** End **********/
}






node * delHas(node * h, int n)
{
    // 请在此添加代码，补全函数delHas
    /********** Begin *********/
   node* pur=h->next,*pre=h;
   while(pur->data!=n)
   {
     pur=pur->next;
     pre=pre->next;
   }
pre->next=pur->next;
return h;


    /********** End **********/
}

// 函数delList：删除链表，释放空间
// 参数：h-链表头指针
void delList(node *h)
{
    node *p=h->next;  // 指针p指向头结点，第一个要删除的结点
    while(p)  // 这个结点是存在的
    {
        h = h->next;  // 头指针h指向下一个结点（下一个结点的地址存在当前结点的指针域中，即h->next中
        delete p;  // 删除p指向的结点
        p = h;  // p指向当前的头结点，即下一个要删除的结点
    }
}
// 函数printList：输出链表，每个数据之间用一个空格隔开
// 参数：h-链表头指针
void printList(node *h)
{
    printf("List:");
    node* p = h->next;
    while(p)
    {// h为真，即h指向的结点存在，则输出该结点的数据
        printf(" %d",p->data);  // 输出结点数据
        p=p->next;  // 将该结点的指针域赋值给h，h就指向了下一个结点
    }
    printf("\n"); // 输出换行符
}
int main()
{
    int n,i,local,num;
    node *t;
    node *head=(node *)malloc(sizeof(node));
    head->next = NULL;
    // 输入结点数
    scanf("%d",&n);
    int a[n];
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);  // 输入结点数据
    }

    head = insertTail(head,a,n);

  

    scanf("%d",&i);
 
    node *np = delHas(head,i);
   // printf("Localtion:%d\n",local);

    // 输出链表
    printList(np);
    // 删除结点，释放空间
    //delList(head);

    return 0;
}

第6关：线性表长度


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

// 定义结点结构
struct node
{
    int data;  // 数据域
    node * next;  //指针域,指向下一个结点
};


// 函数listLength：计算并返回链表的长度
// 参数：h-链表头指针
// 返回值：链表长度
int listLength(node * h)
{
    // 请在此添加代码，补全函数listLength
    /********** Begin *********/
    int count=0;
    node* newhead=h;
    while(newhead->next)
    {
        count++;
        newhead=newhead->next;
    }
 return count;
    /********** End **********/
}


// 函数delList：删除链表，释放空间
// 参数：h-链表头指针
void delList(node *h)
{
    node *p=h->next;  // 指针p指向头结点，第一个要删除的结点
    while(p)  // 这个结点是存在的
    {
        h = h->next;  // 头指针h指向下一个结点（下一个结点的地址存在当前结点的指针域中，即h->next中
        delete p;  // 删除p指向的结点
        p = h;  // p指向当前的头结点，即下一个要删除的结点
    }
}
// 函数printList：输出链表，每个数据之间用一个空格隔开
// 参数：h-链表头指针
void printList(node *h)
{
    printf("List:");
    node* p = h->next;
    while(p)
    {// h为真，即h指向的结点存在，则输出该结点的数据
        printf(" %d",p->data);  // 输出结点数据
        p=p->next;  // 将该结点的指针域赋值给h，h就指向了下一个结点
    }
    printf("\n"); // 输出换行符
}


int main()
{
    int n,i,local,num;
    node *t;
    node *head=(node *)malloc(sizeof(node));
    head->next = NULL;
    node *p = head;
    scanf("%d",&n);
    while(n>0)
    {
        //为新节点动态分配空间
        t = new node;
        t->data = n; //结点数据赋值
        t->next=NULL;  //结点指针域值为空
        //按输入顺序构建链表

        p->next = t;
        p = p->next;
        scanf("%d",&n);
    }

    int length = listLength(head);
    printf("List length:%d",length);

    // 删除结点，释放空间
    //delList(head);

    return 0;
}

【头歌】单链表的基本操作
qq_39977056的博客
01-23 1万+
由于单链表中每个结点的存储地址是存放在其前趋结点的指针域中的，而第一个结点无前趋，头指针L指向第一个结点，对于整个单链表的读取必须从头指针开始，同时，由于单链表中最后一个结点的指针域为“空”（NULL），没有直接后继元素，对于整个单链表的读取必须在尾结点结束。要在带头结点的单链表L中删除第i个结点，则同样要先找到第i-1个结点，使p指向第i-1个结点，使q指向第i个结点，然后令第i-1个结点的指针域指向第i+1个结点，而后删除q指向的第i个结点并释放结点空间。= NULL时，才能进行删除结点的操作。
第一关（青铜）：链表定义及基本操作
zjynb1的博客
07-19 114
节点相互链接每个节点最多一个后继节点。
算法村第一关青铜-链表操作
qq_52511784的博客
07-18 78
链表的常见基本操作
【第1关：基于循环链表的队列的基本操作】【编程题实训-队列】【头歌】【ｂｊｆｕ２４６】
Tommy_Nike的博客
11-13 6501
ｂｊｆｕ－２４６
【数据结构-链表】静态链表建立与基本操作
zkk2002的博客
10-21 467
静态链表建立与基本操作
第1关：有序单链表的插入操作【头歌】
shaojiuli的博客
05-01 2900
int ListSortInsert (LinkList &L, ElemType e,int (*compare)(ElemType,ElemType)) { /********** Begin **********/ LNnode* s = (LNnode*)malloc(sizeof(LNnode)),*p,*q; if (s == NULL) return 0; s->data = e; s->next = NULL; p = L; q = L->nex.
头歌任务10-02-01 链表操作-创建、追加和输出
04-01
在头歌EDU平台上，可以通过多种编程语言实现链表的操作任务。以下是基于C++、C以及Python三种常见语言的链表创建、追加和输出的具体实现方式。 --- #### C++ 实现链表尾插法 通过定义`LinkedList`类及其成员函数来...
01链表1
08-03
这种非连续的存储方式赋予了链表在进行插入和删除操作时的高度灵活性。 在处理链表时，我们通常会考虑以下几个方面：如何实现数据结构中节点的创建、如何进行链表的遍历、以及如何在链表中进行元素的插入和删除。在...
链表操作在Win32 VS环境下的实现
在Windows操作系统平台上使用Visual Studio（VS）进行链表操作是学习和实践C/C++编程的一个重要环节。Visual Studio 是一个集成开发环境（IDE），它提供了代码编辑、调试、代码库管理以及与其他工具集成等功能，极大...
二叉搜索树与双向链表01
08-03
二叉搜索树（Binary Search Tree, BST）是一种特殊的二叉树结构，它的每个节点都包含一个整数值，且满足以下...通过这样的转换，我们可以方便地在保持有序性的前提下，利用链表的特性进行高效的操作，如插入、删除等。
数组和链表的优缺点 (1) 数组和链表(01).docx
04-18
这种灵活性使得链表非常适合于需要频繁进行插入和删除操作的应用场景。 ### 总结 综上所述，数组和链表各有优势和局限性。选择哪种数据结构取决于具体的应用需求。如果需要频繁地访问数据或内存空间有限，那么数组...
第1关：单循环链表的实现—链表的添加、遍历任务描述相关知识单循环链表添加操作遍历循环链表编程要求测试说明任务描述在操作单链表时，
qq_64001869的博客
10-17 3210
在操作单链表时，我们有时希望从单链表中的任一结点出发都能遍历整个链表，但对于单链表来说，只有从头结点开始才能扫描表中的全部结点。因此我们需要改动链表，使其首尾相接，这样就能满足我们的需求。单循环链表的添加操作与普通的单链表操作类似，只需添加时注意处理尾结点，使其指向头结点。改为指向表头结点或开始结点，就得到单链形式的循环链表，称为单循环链表。由于有头结点，所以空表和非空表的处理方式是一样的。本关任务：完成带头结点的单循环链表的添加功能，遍历链表并输出。这里采用的是尾插法，即在链表的末尾添加结点。
链表的基本操作
eminemi的博客
07-13 7531
链表的基本操作包括建立（批量存入数据）、打印（输出所有数据）、删除（在批量数据中删除指定数据）、插入（在批量数据中添加一个数据）等。
循环单链表的基本操作
qq_62949330的博客
10-28 3686
第一关：循环单链表的初始化、插入及输出操作； 第二关：循环单链表的删除操作； 第三关：两个循环单链表的合并操作。
4-单链表及其有关操作
m0_61151031的博客
04-20 2333
链表及其有关操作 链表的定义： 首先先让我们来看看什么是链表： 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的，链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。 由上面我们不难发现，链表就是一系列零散的点，通过指针作为引线，在内存中串起来的一组数据。还有一个值得我们注意的是，链表是非顺序的存储结构，与我们的数组不同，虽然两者都是一组数据，但是数组在内存中是连续存储的。 然后还有一个值得注意的点是，链表中的元素是动态生成的，.
算法竞赛备赛——【图论】求最短路径——Bellman-Ford & SPFA
2302_79975436的博客
07-18 430
存图：边集数组/二维vector/链式前向星最多松弛n-1轮每松弛一轮至少可以确定一个点的最短距离，每一轮至少有一条边被松弛掉不能求负权回路，但可以检验负环。
Java机考题：815. 公交路线 图论BFS
2301_81193552的博客
07-19 313
最优策略是先乘坐第一辆公交车到达车站 7 , 然后换乘第二辆公交车到车站 6。出发，每次尝试乘坐当前车站的所有公交车，并记录到达新车站的最小换乘次数。车站出发（初始时不在公交车上），要前往。：一旦某辆公交车的路线被遍历过，就标记为。，表示一系列公交线路，其中每个。如果不可能到达终点车站，返回。记录每个车站有哪些公交车经过。辆公交车将会在上面循环行驶。期间仅可乘坐公交车。表示一条公交线路，第。没有公交车经过，返回。
【PTA数据结构 | C语言版】求单源最短路的Dijkstra算法
等风来
07-21 292
请编写程序，实现在带权的有向图中求单源最短路的 Dijkstra 算法。注意：当多个待收录顶点路径等长时，按编号升序进行收录。输入格式：输入首先在第一行给出两个正整数，依次为当前要创建的图的顶点数 n（≤100）和边数 m。随后 m 行，每行给出一条有向边的起点编号、终点编号、权重。顶点编号从 0 开始，权重（≤100）为整数。同行数字均以一个空格分隔。
图论的整合
最新发布
STY_fish_2012的博客
07-22 600
所以可以考虑枚举每一头牛，然后记他们可以到达的点，最后的答案就有所有牛都能到达点的数量。的所有邻接点，邻接点按照度数由小到大输出,如果度数相等，则按照编号有小到大输出。一张无向图，如果任意一个点都可以到达图上的所有点，那么这张无向图就是连通图。由小到大依次输出每个点的邻接点，邻接点也按照由小到大的顺序输出。最开始，除了起点外所有点没有被标记过，起点是最开始被选中的点。（两个点之间不是必须相连）开始模拟：找到被选中的点连接的最小边权的且没有被标记过的点。被标记，并成为下一个被选中的点，直到所有点都被标记。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值