单链表 双链表 环链表的简单操作

最新推荐文章于 2022-07-08 21:52:23 发布
最新推荐文章于 2022-07-08 21:52:23 发布
阅读量250 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35649005/article/details/52194817
版权
#if 0
typedef struct node
{
 int n;
 struct node *next;
}Node;
Node *creat();
void print(Node *head);
Node *sort(Node *head);  //排序
Node *swap(Node *head);  //逆序
int main()
{
 Node *head = creat();
 print(head);
 head=sort(head);
 print(head);
 head=swap(head);
 print(head);
 return 0;
}
Node *creat()
{
 Node *head=NULL,*p1=NULL,*p2=NULL;
 p1 = (Node*)malloc(sizeof(Node));
 p1->next = NULL;
 while (1 == scanf("%d",&p1->n))
 {
    if (head ==NULL)
head = p1;
else 
p2->next = p1;
p2 = p1;
p1 = (Node*)malloc(sizeof(Node));
p1->next = NULL;
 }
 free(p1);
 p1 = NULL;
 return head;
 }
void print(Node *head)
{
 Node *p = head;
 while (p !=NULL)
 {
 printf("%d ",p->n);
 p = p->next;
 }
 printf("\n");
}
Node *sort(Node *head)
{
 Node *newhead=NULL,*newtail=NULL,*p,*min,*minf;
 if (head == NULL || head->next == NULL)
 return head;
 while (head != NULL)
 {
  p = min = head;
  for (; p->next!=NULL ; p = p->next )
  { 
     if (p->next ->n <min ->n) //第一步先遍历一次找到最小的，min始终指向最小的。
 {                         //而minf始终指向min前面的那一个。
  min = p->next ;
  minf =p; 
 }
  }
   //2
 if (newhead==NULL)   //第一次的时候将 newhead 和 newtail都指向min;
 {
  newhead = newtail =min;
 }
 else    //下一次的时候 将newtail->next 里面存放 下一次遍历的最小值；
 {       //再将newtail指向min
   newtail->next = min;
   newtail = min;
 }
 //3  删除
 if (min ==head) //如果找到的最小值刚好是head的话，就将head指向head的下一个
 head = head->next ;
 else 
 minf->next = min->next;  //否则的话 将minf里面的next指向min的下一个
  }
 if (newhead!=NULL)
 newtail->next =NULL; //将最后一个里面的next指向为NULL
 return newhead;
 }
Node *swap(Node *head)
{
  Node *p=NULL,*pf=NULL,*pn=NULL;
  if (head ==NULL ||head->next ==NULL)
  return head;
  pf = head;   //先将pf指向head
  p =pf->next ; //将p指向head的下一个，
  pf->next =NULL; //先将pf->next指向为0
  while (p ->next !=NULL)
  {
        pn = p->next; //先让pn指向p的下一个
p->next = pf; //将p->next先指向pf
pf = p;   //再将pf指向p
p = pn;   //p再指向pn
  }
  p ->next =pf;
  head = p;
  return head;
}
#endif
#if 0
typedef struct node
{
 int n;
 struct node *next;
}Node;
void test(Node *head); //如何找到链表的中间位置，定义两个指针，都指向head,其中一个指针每次增加两次，另
int main()               //一个指针每次增加一次。当第一个指针走到结尾的时候，第二个指针就在中间
{
 Node *head;
 head=test(head);
 return 0;
}
void test(Node *head)
{
 Node *p1=NULL,*p2=NULL;
 p1 = p2 =NULL;
 while (p1 != NULL)
 {
  p1 = p1->next ;
  if (p1 != NULL)
  {
  p1 = p1->next;
  p2 = p2->next; 
  }
 }
}
#endif
#if 0
typedef struct data    //循环链表 ，最后一个结点里面不指向为0，指向head；
{
int n;
struct data *next;
}Node;
Node *create();
void print(Node *head);
int main()
{
 Node *head=create();
 print(head);
 return 0;
}
Node *create()
{
Node *head=NULL,*p1=NULL,*p2=NULL;
p1 = (Node*)malloc(sizeof(Node));
p1->next = NULL;
while(1 == scanf("%d",&p1->n))
{
if(head == NULL)
head = p1;
else
p2->next = p1;
p2 = p1;
p1 = (Node*)malloc(sizeof(Node));
p1->next = NULL;
}
free(p1);
p1 = NULL;
p2->next = head;
return head;
}
void print(Node *head)
{
Node *p = head;
do         //循环链表在输出的时候，应该把判断条件改了。
{
printf("%d ",p->n);
p = p->next;
}while(p != head);
printf("\n");
}
#endif
#if 0
typedef struct data
{
int n;
struct data *next;
struct data *front;
}Node;
Node *create();
void print(Node *head);
int main()
{
 Node *head =create();
 print(head);
 return 0;
}
Node *create()
{
 Node *head=NULL,*p1=NULL,*p2=NULL;
 p1=(Node*)malloc(sizeof(Node));
 p1->front = NULL;
 p1->next  = NULL;
 while (1 == scanf("%d",&p1->n ))
 {
  if (head ==NULL)
     head =p1;
  else
  {
   p2->next =p1; //双指针就是在多了一个存放前面地址的指针。
   p1->front =p2;  //
  }
  p2 = p1;
  p1=(Node*)malloc(sizeof(Node));
  p1->front = NULL; //每次在定义新的指针的时候记得将指针指向为空就行了。
  p1->next  = NULL; //
 }
 free(p1);
 p1 = NULL;
 return head;
}
void print(Node *head)
{
 Node *p = head,*p1 = NULL;  //在输出双指针的时候，只要记得将两个指针的分别存放的地址是什么就可以弄清楚
while(p != NULL)
{
p1= p;
printf("%d ",p->n);
p = p->next;
}
printf("\n");
while(p1 != NULL)
{
printf("%d ",p1->n);
p1 = p1->front;
}
printf("\n");
}
#endif
#if 0  //链表的插入
typedef struct data
{
int n;
struct data *next;
}Node;
Node *creat();
Node *find(Node *head,int key);     //找到关键字的位置
void insert(Node *head,int newdata,int key);  //插入
void print(Node *head);
int main()
{
 int key,newdata=9;
 Node *head;
 printf("输入要插在那个数的后面：key=");
 scanf("%d",&key);
 printf("input numbers:\n");
 head=creat();
 insert(head,9,key);
 print(head);
 return 0;
}
Node *creat()
{
 Node *head=NULL,*p1=NULL,*p2=NULL;
 p1 = (Node*)malloc(sizeof(Node));
 p1->next = NULL;
 while (1 == scanf("%d",&p1->n))
 {
    if (head ==NULL)
head = p1;
else 
p2->next = p1;
p2 = p1;
p1 = (Node*)malloc(sizeof(Node));
p1->next = NULL;
 }
 free(p1);
 p1 = NULL;
 return head;
 }
Node *find(Node *head,int key)  //找到关键字的位置
{
 Node *p1 =NULL,*p2 = NULL;
 p1 =head;
 for (;p1->next !=NULL; p1 =p1->next )
 {
 if (p1->n ==key)
 p2 = p1;
 }
 if (p2 !=NULL)
 return p2;
 else 
 return NULL;
}
void insert(Node *head,int newdata,int key)
{
 Node *newnode = NULL;  //新建一个结点
 Node *p1 =find(head,key); //p1是插入位置之前的结点指针
 newnode=(Node *)malloc(sizeof(Node)); //给结点开辟新的内存
 newnode->n =newdata;   //newdata是新结点的数据
  if (head ==NULL||p1==NULL)  //如果链表没有结点 或者找不到关键字的结点
  {
  newnode->next=head; //就插入到表头位置   先连接起来
  head =newnode;  // 再断开
  }
  else   
  {
  newnode->next=p1->next;  //否则 就插入在p1的后面， 先连接
  p1->next=newnode;  //再断开
  }
}
void print(Node *head)
{
Node *p = head;
while(p != NULL)
{
printf("%d ",p->n);
p = p->next;
}
printf("\n");
}
#endif
#if 0
typedef struct data
{
int n;
struct data *next;
}Node;
Node *creat();
void print(Node *head);
Node* find(Node *head,int key);
void Delete(Node *head,int key);
int main()
{
 Node *head;
 int key=5;
 printf("input numbers:");
 head=creat();
 //printf("要删除的关键字:key=");
 //scanf("%d",&key);
 Delete(head,key);
 return 0;
}
Node *creat()
{
 Node *head=NULL,*p1=NULL,*p2=NULL;
 p1 = (Node*)malloc(sizeof(Node));
 p1->next = NULL;
 while (1 == scanf("%d",&p1->n))
 {
    if (head ==NULL)
head = p1;
else 
p2->next = p1;
p2 = p1;
p1 = (Node*)malloc(sizeof(Node));
p1->next = NULL;
 }
 free(p1);
 p1 = NULL;
 return head;
 }
Node* find(Node *head,int key)
{
 Node *p1=head,*p2=NULL,*p3=NULL;
 if (head->n ==key)
 return p2;
 else
 {
 for (; p1->next !=NULL;p3=p1, p1 =p1->next )
 {   
  if (p1->n == key)
  p2 =p3;
 }
 if (p2 !=NULL)
 return p2;
 else 
 return NULL;
 }
}
void Delete(Node *head,int key)
{
 Node *p=NULL,*p1=find(head,key);

 if (head!=NULL)
 {
    if (head->n ==key)
{
     p=head;
 head=head->next;
 free(p);
 print(head);
}
else 
{
     while (p1!=NULL)
 {
 if (p1->next->n==key)
 {
 p=p1->next;
 p1->next=p->next;
 free(p);
 print(head);
 p1 =NULL;
 }
 }
}
 }
 else 
 printf("没找到关键字或者链表为空\n");
}
void print(Node *head)
{
Node *p = head;
while(p != NULL)
{
printf("%d ",p->n);
p = p->next;
}
printf("\n");
}
#endif
西厢eva
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
451. 两两交换链表中的节点（swap-nodes-in-pairs）(c++)----lintcode面试题之链表
musclegao的博客
02-18 555
（一）题目要求：给一个链表，两两交换其中的节点，然后返回交换后的链表。（二）示例：给出 1-&gt;2-&gt;3-&gt;4, 你应该返回的链表是 2-&gt;1-&gt;4-&gt;3。你的算法只能使用常数的额外空间，并且不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。（三）题解：方法一：/** * Definition for singly-linked list. * st...
双链表结点交换真的那么简单吗？||c语言解析
李志杰的博客
10-08 291
最近在做一道面试题，问道交换双链表的结点，真的就那么简单吗？ 问题涉及的情况比较多，两个结点可能出现在头、尾以及中间，并且两个结点是否相邻都会影响操作的正确性，下面给出代码，包含了所有可能出现的情况。 struct Node { struct Node* next;//下一个结点指针 struct Node *pre;//上一个结点指针 int data;//数据 }; struct BilList { struct Node* first;//头节点 struct Node *l
java: 数据结构---栈(链表)
eyeofeagle的博客
07-11 439
链表的结构如下:( 1, head是一个引用地址, 用来指引最新的数据[ 栈: 先进后出]Node newNode=new Node(data); 2, 新加入的数据被封装为Node对象, 若容器为空时, 新node没有下一个;Node tmp=head;...
数据结构与算法初阶4：链表—带头双向循环链表知识讲解
King_lm_Guard的博客
07-08 450
数据结构与算法初阶篇：带头双向循环链表相关知识讲解。
单链表双链表python示例.rar
05-22
本资源“单链表双链表python示例.rar”包含了关于链表的Python实现，特别是单链表和双链表。 单链表是一种每个节点包含数据和指向下一个节点的引用的数据结构。在Python中，我们可以使用类来表示链表的节点，如下所...
单链表双向链表ADT_C语言项目
04-04
Singly Linked List： 1. DestroyList 2. InsertList 3. DeleteList 4. TraverseList 5. SearchList 6. ReverseList 7. IsLoopList 8. ReverseEvenList 9. FindMidNode ...5. TraverseList_DuL
单链表、双链表、循环链表的操作
04-19
链表可以分为单链表、双链表和循环链表三种，下面我们将详细介绍这些链表的操作。 单链表 单链表是一种基本的链表结构，其中每个节点只有一个指针指向下一个节点。单链表的实现可以通过结构体来实现，如上面的代码...
循环单链表-双链表_循环单链表-双链表_throat6v2_
09-30
双链表的插入和删除操作通常比单链表更复杂，因为需要更新更多的指针，但它们提供了更多的灵活性。 双链表的主要操作包括： 1. 插入节点：在双链表中插入节点，需要同时更新前后两个相邻节点的指针。 2. 删除节点：...
学生信息系统 单链表 双链表
07-13
单链表和双链表是两种常用的数据结构，特别是在处理动态数据时，如学生的添加、删除和更新操作。 单链表是一种线性数据结构，每个元素（节点）包含两部分：数据域存储实际信息，如学生姓名、学号等；指针域存储下一...
双链表交换相邻结点
weixin_34372728的博客
11-13 1130
Swap(LinkNode low,LinkNode high)//交换两个结点 { low->prior->next=high;high->prior=low->prior; high->next->prior=low; low->next=high->next; high->next=low; ...
两两交换链表中的节点(Swap Nodes in Pairs)
qq_40590014的博客
05-25 488
两两交换链表中的节点(Swap Nodes in Pairs) 2019年5月25日 题目描述: 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例: 给定 1->2->3->4, 你应该返回 2->1->4->3. 链表...
双向链表的节点交换
crazybears的专栏
09-19 7602
这两天关于双向链表的节点的交换,用了很长的时间去学习,理解,敲了好多次,总是达不到效果,就是能想明白,但是在写的时候不是出现这样就是那样的问题,最后参照另外一位CSDN博主的帖子,才写出一个完整的函数, 贴上代码,以便自己以后随时查看,没有图. void swap(USERINFO *head,USERINFO *left,USERINFO *right) { USERINFO *temp...
双向循环链表两个节点交换的原则
moses1213的专栏
10-31 6818
假设q是p的前驱结点；  总共分三阶段  1.p与新前驱建立联系  q->llink->rlink=p; p->link=q->llink; 2.q与新后驱建立联系  p->rlink->llink=q; q-rlink=p->rlink; 3.p与q互连 p->rlink=q; q->llink=p; :总结一下其实在交换过程中要注意的就是不能丢掉前后两端结点的
c++基础值链表基本操作
someday1314的博客
03-29 587
SeqListD.cinclude”SeqListD.h”void InitList(PNode* pHead) { assert(pHead); *pHead=NULL; } Node *BuyNode(DataType data) { Node pNewNode=(Node)malloc(sizeof(Node)); if(pNewNode
用链表来实现学生信息的存储
JUST DO IT
03-10 7211
链表是线性表的链式存储结构，有单链表、循环单链表、双链表、循环双链表、顺序链表。 链表不能够进行随机访问，但在插入和删除数据时不需要移动元素，比顺序结构操作简单。 简单程序实现： #include #include using namespace std; struct student//建立学生信息链表结构体 {   int num;   float score;   str
安全技术交底记录.docx
07-13
安全技术交底记录.docx
质量隐患整改通知单.docx
07-13
质量隐患整改通知单.docx
android studio项目实例
最新发布
07-13
创建一个简单的Android Studio项目实例可以帮助你理解Android应用开发的基础。以下是使用Android Studio创建一个基本的"Hello World" Android应用的步骤： ### 1. 环境准备 确保你已经安装了最新版本的Android Studio。可以在[Android Studio官网](https://developer.android.com/studio)下载。 ### 2. 创建新项目 - 打开Android Studio，点击“Start a new Android Studio project”。 - 选择一个项目模板，对于初学者来说，选择“Empty Activity”即可。 - 填写应用的名称、包名和保存位置，选择保存语言（Java或Kotlin），然后点击“Finish”。 ### 3. 理解项目结构 项目创建完成后，你将看到以下主要组成部分： - `app`：包含所有应用特定的代码。 - `src/main`：包含源代码和资源。 - `java/<package-name>`：源代码目录。 - `res`：资源目录，

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值