C语言数据结构之链表部分（7）

最新推荐文章于 2023-06-12 17:10:46 发布
最新推荐文章于 2023-06-12 17:10:46 发布
阅读量173 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43437044/article/details/104763767
版权

7.带表头节点的单向链表

（1）创建带表头节点的单向链表

#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node
{
      int data;
      struct node * next;
}ElemSN;
ElemSN * Createlink(int a[],int n);//创建带表头单向链表
void Printlink(ElemSN *h);//打印带表头单向链表
int main()
{
      int a[N] = {10,20,30,40,50};
      ElemSN *head;
      //创建带表头单向链表
      head = Createlink(a,5);
      //打印原链表
      printf("原链表为：");
      Printlink(head);
      printf("\n");

      return 0;
}
（2）创建带表头单向链表
ElemSN * Createlink(int a[],int n)
{
      ElemSN *h,*t,*p;
      h = (ElemSN *)malloc(sizeof(ElemSN));
      t = h;
      for(int i = 0;i < n;i++)
      {
            p = (ElemSN *)malloc(sizeof(ElemSN));
            p->data = a[i];
            p->next = NULL;
            t->next = p;
            t = p;
      }
      return h;
}
//打印链表
void Printlink(ElemSN *h)
{
      ElemSN *p;
      for(p = h;p->next;p = p->next)
      {
            printf("%d ",p->next->data);
      }
}

（2）删除关键字

#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node
{
      int data;
      struct node * next;
}ElemSN;
ElemSN * Createlink(int a[],int n);//创建带表头单向链表
void Printlink(ElemSN *h);//打印带表头单向链表
void Delkeynode(ElemSN * h,int key);//删除关键字
int main()
{
      int a[N] = {10,20,30,40,50};
      ElemSN *head;
      //创建带表头单向链表
      head = Createlink(a,5);
      //打印原链表
      printf("原链表为：");
      Printlink(head);
      printf("\n");
      //删掉关键字
      printf("输入关键字：");
      int key;
      scanf("%d",&key);
      printf("删除关键字结果为：");
      Delkeynode(head,key);
      Printlink(head);
      printf("\n");

      return 0;
}
//创建带表头单向链表
ElemSN * Createlink(int a[],int n)
{
      ElemSN *h,*t,*p;
      h = (ElemSN *)malloc(sizeof(ElemSN));
      t = h;
      for(int i = 0;i < n;i++)
      {
            p = (ElemSN *)malloc(sizeof(ElemSN));
            p->data = a[i];
            p->next = NULL;
            t->next = p;
            t = p;
      }
      return h;
}
//打印链表
void Printlink(ElemSN *h)
{
      ElemSN *p;
      for(p = h;p->next;p = p->next)
      {
            printf("%d ",p->next->data);
      }
}
//删除关键字
void Delkeynode(ElemSN * h,int key)
{
      ElemSN *p,*Delp;
      for(p = h;p->next && p->next->data != key;p=p->next);
            if(!p->next)
            {
                  printf("没找着");
            }
            else
            {
                  Delp = p->next;
                  p->next = Delp->next;
                  free(Delp);
            }
}

（3）删掉无序重复关键字

#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct node
{
      int data;
      struct node * next;
}ElemSN;
ElemSN * Createlink(int a[],int n);//创建带表头单向链表
void Printlink(ElemSN *h);//打印带表头单向链表
void Delkeynode(ElemSN * h,int key);//删除无序且重复关键字
int main()
{
      int a[N] = {1,1,2,1,3,5,1,1};
      ElemSN *head;
      //创建带表头单向链表
      head = Createlink(a,8);
      //打印原链表
      printf("原链表为：");
      Printlink(head);
      printf("\n");
      //删掉无序重复关键字
      printf("输入关键字：");
      int key;
      scanf("%d",&key);
      Delkeynode(head,key);
      Printlink(head);
      printf("\n");

      return 0;
}
//创建带表头单向链表
ElemSN * Createlink(int a[],int n)
{
      ElemSN *h,*t,*p;
      h = (ElemSN *)malloc(sizeof(ElemSN));
      t = h;
      for(int i = 0;i < n;i++)
      {
            p = (ElemSN *)malloc(sizeof(ElemSN));
            p->data = a[i];
            p->next = NULL;
            t->next = p;
            t = p;
      }
      return h;
}
//打印链表
void Printlink(ElemSN *h)
{
      ElemSN *p;
      for(p = h;p->next;p = p->next)
      {
            printf("%d ",p->next->data);
      }
}
//删除无序重复关键字
void Delkeynode(ElemSN * h,int key)
{
      ElemSN *p,*Delp;
      for(p =h;p->next;)
      {
            if(p->next->data == key)
            {
                  Delp = p->next;
                  p->next = Delp->next;
                  free(Delp);
            }
            else
            {
                  p = p->next;
            }
      }
}

（4）

就地逆置
#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node
{
      int data;
      struct node * next;
}ElemSN;
ElemSN * Createlink(int a[],int n);//创建带表头单向链表
void Printlink(ElemSN *h);//打印带表头单向链表
ElemSN * Renode(ElemSN *h);//就地逆置
int main()
{
      int a[N] = {10,20,30,40,50};
      ElemSN *head;
      //创建带表头单向链表
      head = Createlink(a,5);
      //打印原链表
      printf("原链表为：");
      Printlink(head);
      printf("\n");
      //就地逆置
      printf("逆置结果为：");
      Renode(head);
      Printlink(head);
      printf("\n");

      return 0;
}
//创建带表头单向链表
ElemSN * Createlink(int a[],int n)
{
      ElemSN *h,*t,*p;
      h = (ElemSN *)malloc(sizeof(ElemSN));
      t = h;
      for(int i = 0;i < n;i++)
      {
            p = (ElemSN *)malloc(sizeof(ElemSN));
            p->data = a[i];
            p->next = NULL;
            t->next = p;
            t = p;
      }
      return h;
}
//打印链表
void Printlink(ElemSN *h)
{
      ElemSN *p;
      for(p = h;p->next;p = p->next)
      {
            printf("%d ",p->next->data);
      }
}
//就地逆置
ElemSN * Renode(ElemSN *h)
{
      ElemSN *p,*q,*h1;
      p = h;
      q = h->next;
      h1 = NULL;
      while(p->next)
      {
            p->next = q->next;
            q->next = h1;
            h1 = q;
            q = p->next;
      }
      h->next = h1;
      return h;
}
//就地逆置2
ElemSN * Renode(ElemSN *h)
{
      ElemSN *p,*h1;
      h1 = NULL;
      while(h->next)
      {
            p = h->next;
            h->next = p->next;
            p->next = h1;
            h1 = p;         
      }
      h->next = h1;
      return h;
}

（5）输出带表头节点的升序链表

#include <stdio.h>
#include <stdlib.h>
#define N 6
typedef struct node
{
      int data;
      struct node * next;
}ElemSN;
ElemSN * Createlink(int a[],int n);//创建带表头单向链表
void Printlink(ElemSN *h);//打印带表头单向链表
ElemSN * LTBnode(ElemSN *h);//带表头节点的升序链表
int main()
{
      int a[N] = {3,2,5,8,4,7};
      ElemSN *head;
      //创建带表头单向链表
      head = Createlink(a,6);
      //打印原链表
      printf("原链表为：");
      Printlink(head);
      printf("\n");
      //单向链表升序
      printf("升序结果为：");
      head = LTBnode(head);
      Printlink(head);
      printf("\n");

      return 0;
}
//创建带表头单向链表
ElemSN * Createlink(int a[],int n)
{
      ElemSN *h,*t,*p;
      h = (ElemSN *)malloc(sizeof(ElemSN));
      t = h;
      for(int i = 0;i < n;i++)
      {
            p = (ElemSN *)malloc(sizeof(ElemSN));
            p->data = a[i];
            p->next = NULL;
            t->next = p;
            t = p;
      }
      return h;
}
//打印链表
void Printlink(ElemSN *h)
{
      ElemSN *p;
      for(p = h;p->next;p = p->next)
      {
            printf("%d ",p->next->data);
      }
}
//带表头节点的升序链表
ElemSN * LTBnode(ElemSN *h)
{
      ElemSN *p,*q,*h1,*pmax;
      q = h->next;
      p = h;
      h1 = NULL;
      while(q->next)
      {
            for(;q->next;q = q->next)
            {
                  if(p->next->data < q->next->data)
                  {
                        p = q;     
                  }
            }
            pmax = p->next;
            p->next = pmax->next;
            pmax->next = h1;
            h1 = pmax;
            p = h,q = h->next;

      }
      h->next->next = h1;
      return h;
}

（6）合并

#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node
{
      int data;
      struct node * next;
}ElemSN;
ElemSN * Createlink(int a[],int n);//创建带表头单向链表
void Printlink(ElemSN *h);//打印带表头单向链表
ElemSN * Mergelink(ElemSN *h1,ElemSN *h2);//合并
int main()
{
      int a[N] = {2,2,2,5,6};
      int b[10] = {1,3,3,5,6,8,8,8,9,10};
      ElemSN *head,*head1,*head2;
      //创建带表头单向链表
      head1 = Createlink(a,5);
      head2 = Createlink(b,10);
      //打印原链表
      printf("原链表1为：");
      Printlink(head1);
      printf("\n");
      printf("原链表2为：");
      Printlink(head2);
      printf("\n");
      //合并
      printf("合并结果为：");
      head = Mergelink(head1,head2);
      Printlink(head);
      printf("\n");

      return 0;
}
//创建带表头单向链表
ElemSN * Createlink(int a[],int n)
{
      ElemSN *h,*t,*p;
      h = (ElemSN *)malloc(sizeof(ElemSN));
      t = h;
      for(int i = 0;i < n;i++)
      {
            p = (ElemSN *)malloc(sizeof(ElemSN));
            p->data = a[i];
            p->next = NULL;
            t->next = p;
            t = p;
      }
      return h;
}
//打印链表
void Printlink(ElemSN *h)
{
      ElemSN *p;
      for(p = h;p->next;p = p->next)
      {
            printf("%d ",p->next->data);
      }
}
//合并
ElemSN * Mergelink(ElemSN *h1,ElemSN *h2)
{
      ElemSN *head3,*p,*q;
      head3 = q =(ElemSN *)malloc(sizeof(ElemSN));
      head3->next = NULL;
      while(h1->next && h2->next)
      {
            if(h1->next->data < h2->next->data)
            {
                  p = h1->next;
                  h1->next = p->next;
                  p->next = NULL;
                  q->next = p;
                  q = p;
            }
            else
            {
                  p = h2->next;
                  h2->next = p->next;
                  p->next = NULL;
                  q->next = p;
                  q = p;
            }
      }
      if(h1)
      {
            q->next = h1->next;
          /*  while(h1->next)
            {
                  p = h1->next;
                  h1->next = p->next;
                  p->next = NULL;
                  q->next = p;
                  q = p;
            }*/
      }
      if(h2)
      {
            q->next = h2->next;
           /* while(h2->next)
            {
                  p = h2->next;
                  h2->next = p->next;
                  p->next = NULL;
                  q->next = p;
                  q = p;
            }*/
      }
      return head3;
}

（7）删除合并后带重复结点的值

#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node
{
      int data;
      struct node * next;
}ElemSN;
ElemSN * Createlink(int a[],int n);//创建带表头单向链表
void Printlink(ElemSN *h);//打印带表头单向链表
ElemSN * Mergelink(ElemSN *h1,ElemSN *h2);//合并
ElemSN * Delsamenode(ElemSN *h);//删除重复的结点
int main()
{
      int a[N] = {2,2,2,5,6};
      int b[10] = {1,3,3,5,6,8,8,8,9,10};
      ElemSN *head,*head1,*head2;
      //创建带表头单向链表
      head1 = Createlink(a,5);
      head2 = Createlink(b,10);
      //打印原链表
      printf("原链表1为：");
      Printlink(head1);
      printf("\n");
      printf("原链表2为：");
      Printlink(head2);
      printf("\n");
      //合并
      printf("合并结果为：");
      head = Mergelink(head1,head2);
      Printlink(head);
      printf("\n");
      //将合并后重复的删掉
      printf("处理后的结果为：");
      head = Delsamenode(head);
      Printlink(head);
      printf("\n");

      return 0;
}
//创建带表头单向链表
ElemSN * Createlink(int a[],int n)
{
      ElemSN *h,*t,*p;
      h = (ElemSN *)malloc(sizeof(ElemSN));
      t = h;
      for(int i = 0;i < n;i++)
      {
            p = (ElemSN *)malloc(sizeof(ElemSN));
            p->data = a[i];
            p->next = NULL;
            t->next = p;
            t = p;
      }
      return h;
}
//打印链表
void Printlink(ElemSN *h)
{
      ElemSN *p;
      for(p = h;p->next;p = p->next)
      {
            printf("%d ",p->next->data);
      }
}
//合并
ElemSN * Mergelink(ElemSN *h1,ElemSN *h2)
{
      ElemSN *head3,*p,*q;
      head3 = q =(ElemSN *)malloc(sizeof(ElemSN));
      head3->next = NULL;
      while(h1->next && h2->next)
      {
            if(h1->next->data < h2->next->data)
            {
                  p = h1->next;
                  h1->next = p->next;
                  p->next = NULL;
                  q->next = p;
                  q = p;
            }
            else
            {
                  p = h2->next;
                  h2->next = p->next;
                  p->next = NULL;
                  q->next = p;
                  q = p;
            }
      }
      if(h1)
      {
            q->next = h1->next;
          /*  while(h1->next)
            {
                  p = h1->next;
                  h1->next = p->next;
                  p->next = NULL;
                  q->next = p;
                  q = p;
            }*/
      }
      if(h2)
      {
            q->next = h2->next;
           /* while(h2->next)
            {
                  p = h2->next;
                  h2->next = p->next;
                  p->next = NULL;
                  q->next = p;
                  q = p;
            }*/
      }
      return head3;
}

ElemSN * Delsamenode(ElemSN *h)
{
      ElemSN *p,*q;
      p = h;
      q = h->next;
      while(q->next)
      {
            if(p->next->data != q->next->data)
            {
                  p = p->next;
                  q = q->next;
            }
            else
            {
                  p->next = q->next;
                  free(q);
                  q = p->next;
            }
      }
      return h;
}

纯菜鸟123456
关注
C语言——（静态）链表
m0_69211839的博客
03-02 196
C语言——（静态）链表
C语言 数据结构之链表实现代码
09-01
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和数据管理。与数组不同，链表的元素不是在连续的内存空间中存储，而是通过指针链接在一起。链表分为多种类型，如单链表、双向链表、循环链表等。本文...
数据结构-图及其应用
qq_73624547的博客
06-12 210
克鲁斯卡尔算法（Kruskal's algorithm）是一种用于生成最小生成树的算法，它的基本思想是先将所有边按照权重从小到大排序，然后从小到大依次加入边，如果加入一条边会形成环，则不加入，直到所有的点都被加入生成树为止。实现了拓扑排序，首先将入度为0的顶点加入队列中，然后依次取出队列中的顶点，并将其相邻的顶点的入度减1，如果减1后入度为0，则将其加入队列中。数组，将源点的距离设为0，然后依次加入未确定最短路径的顶点集合中的距离最小的顶点，并更新其相邻的顶点到源点的距离。最后输出生成树的边和权重。
数据结构（C语言）---图
Weightlessly的博客
12-06 2463
数据结构（C语言）— 图的相关实验 实验目的 1、熟练掌握图的邻接矩阵与邻接表存储结构及其应用。 2、能设计出基于两种遍历算法的相关问题的求解，如深度遍历生成树的求解，广度遍历生成树的求解。 3、理解并掌握最小生成树算法的基本思想及其算法方法。 4、理解并掌握最短路径算法的基本思想及其算法方法。 5、理解并掌握拓扑排序算法的基本思想及其算法方法。 实验内容 1、编写程序输出以邻接表为存储结构的无向图的各顶点的度。 2、图采用邻接表存储结构，编程对图进行广度优先遍历。 3、图采用邻接表存储结构，编程对图进行深
C语言—链表
热门推荐
weixin_73588765的博客
01-01 2万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
数据结构【完整代码】之（C语言实现【图的存储创建遍历】邻接矩阵与邻接表）
Zhou_LC的博客
11-28 2015
一、邻接矩阵 包含四个文件的代码和一张测试效果图： AdjacencyMatrix.h文件： 构建邻接矩阵的存储结构与邻接矩阵的创建函数 DBFSAdjacencyMatrix.h文件： 构建邻接矩阵的深度优先遍历与广度优先遍历函数 StackAndQueue.h文件： 应广度优先遍历所需，提供队列的基本操作 test.cpp文件： 用于测试 效果图：（如下） 效果图： AdjacencyMatrix.h文件： #include<stdio.h> #include<stdlib.h&
C语言 数据结构双向链表简单实例
08-31
C语言数据结构双向链表简单实例 本文主要介绍了C语言数据结构双向链表简单实例的相关知识点，包括双向链表的基本操作、删除元素、插入元素、判断对称性、排序等。 一、双向链表的基本操作 双向链表是一种数据结构...
C语言数据结构旋转链表的实现
12-31
C语言数据结构旋转链表的实现 实例： 给出链表1->2->3->4->5->null和k=2 返回4->5->1->2->3->null 分析： 感觉很直观，直接把分割点找出来就行，记得k可能大于len,要取模 代码： /** * Definition for singly-...
C语言数据结构-链表版学生管理系统
最新发布
10-02
《C语言数据结构-链表版学生管理系统》 在计算机科学中，数据结构是组织、存储和处理数据的重要工具，而链表作为一种基础且灵活的数据结构，被广泛应用于各种复杂算法和系统设计中。本项目《C语言数据结构-链表版...
数据结构-图
xiaodeguang的博客
09-06 901
1、邻接矩阵创建_CreateMGraph #include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXVEX
邻接矩阵的深度优先遍历 c语言 数据结构 简单易懂 超详细~~
weixin_54907221的博客
11-24 2108
#include<stdio.h> #define maxsize 100 #include<stdlib.h> #define INFINITY 65535 int visited[maxsize];//注意这个visited数组必须为全局变量 //因为若为局部变量，在另外一个函数内修改它，在返回到被调函数时，值不会发生改变 typedef struct graph { int arc[maxsize][maxsize];//边表 int vert[maxsize]; int n
邻接矩阵-数据结构(C语言)
weixin_44681349的博客
05-09 1195
邻接矩阵的构造 第一种存储结构- 邻接矩阵。需要注意的事， 我们接下来针对的是有向图。 今后如果遇到无向图的情况，将每条无向图看成有向图中的正反两条有向边即可。 #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_N 500 typedef struct Graph { int mat[MAX_N][MAX_N]; int n; } Graph; // 首先来实现
数据结构实验
花雨的博客
06-19 1135
##长整数加法运算 #include <stdio.h> #include <stdlib.h> #include <ctype.h> typedef struct DualNode { int data; struct DualNode *prior, *next; }DualNode, *DualList; //头节点存放符号位 DualList InitList(int sign) { DualLis
图【MOOC】
WR的博客
11-21 220
图的邻接矩阵表示法 /* 图的邻接矩阵表示法 */ #define MaxVertexNum 100 /* 最大顶点数设为100 */ #define INFINITY 65535 /* ∞设为双字节无符号整数的最大值65535*/ typedef int Vertex; /* 用顶点下标表示顶点,为整型 */ typedef int WeightType; /* 边的权值设为整型 */ typedef char DataType; /* 顶
数据结构——邻接矩阵的创建（C语言）
weixin_42468092的博客
10-08 1519
#include<stdio.h> #include<stdlib.h> #define MaxVertexNum 100 #define ElemType int #define VertexType int typedef struct{//邻接矩阵存储 ElemType Vertices[MaxVertexNum]; //顶点信息的数组 ElemType Edge[MaxVertexNum][MaxVertexNum]; //边信息的数组 ElemTy
第六章--图邻接矩阵实现（两种方式）
a13683857889的博客
02-17 442
邻接矩阵实现（快速建立方式） #include&lt;stdio.h&gt; #define MaxVertexNum 20 int main() { int G[MaxVertexNum][MaxVertexNum]; int Nv,Ne,GData[MaxVertexNum],i,j; int v1,v2,w; printf("请输入结点数和边数:\n"); scanf("%...
12
小森努力努力再努力i
03-27 296
详细代码如下： #include <stdio.h> #include <conio.h> #include <stdlib.h> typedef struct aa { int data; struct aa *next; } NODE; int fun (NODE *h) { int max=-1; NODE *p; /*************found**************/ p=h->next; //因为链表的头结点没有数据域，所以对.
34
小森努力努力再努力i
03-23 95
34 date：2021.3.23 要点： 详细代码如下： #include <stdio.h> #include <stdlib.h> #define N 5 typedef struct node { int data; struct node *next; } NODE; /**********found**********/ NODE * fun(NODE *h) //根据返回值类型即可确定 { NODE *p, *q, *r; p
36(将字符串数组中M个字符串合并成一个新串)
小森努力努力再努力i
03-23 611
36 date：2021.3.22 要点： 详细代码如下： #include <stdio.h> #include <stdlib.h> #define N 5 typedef struct node { int data; struct node *next; } NODE; void fun(NODE *h) { NODE *p, *q, *r; /**********found**********/ p = h->next; /***
C语言数据结构与链表深入解析
资源摘要信息:"C语言进阶－第5讲数据结构与链表" 知识点: 1. C语言基础知识复习 在开始探讨数据结构与链表之前，通常需要对C语言的基础知识进行复习，包括变量声明、数据类型、控制结构、函数定义等基础语法，这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值