王道单链表

已于 2022-07-27 18:14:04 修改
阅读量324 收藏
点赞数
分类专栏： 王道数据结构 文章标签： 链表 数据结构 c++
于 2022-07-22 09:44:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46126118/article/details/125925957
版权

1.按位序插入 （带头结点）

typedef struct LNode{
     ElemType data; // 每个节点存放一个数据元素
     struct LNode *next;  // 指向下一个节点
}LNode,*LinkList；
//按位序插入 （带头结点）
//在第i个位置插入元素e
bool ListInsert(LinkList &L,int i, ElemType e)
{
    if (i<1)
        return false;
    LNode *p;//指针p指向当前扫描的节点
    int j=0；//当前p指向的是第几个节点
    p=L;//L指向头结点，头结点是第0个节点              LNode * GetElem(LinkList L,int i)
    while (p!=NULL && j<i-1) //循环找到第i-1个结点
    {                                                7. 按位查找
        p=p->next;
        j++;
}
    if (p==NULL){
        return false;
    }
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s; // 将节点s连接到p之后
    return true;
}
int main()
{    LinkList L;
     ListInsert(L,6,8);
     return 0;
}

2.按位序插入（不带头结点）

bool ListInsert(LinkList &L,int i, ElemType e)
{
    if (i<1)
        return false;
    if(i==1){
        LNode *s=(LNode *)malloc(sizeof(LNode));
        s->data=e;
        s->next=L;
        return true;
    }   
     LNode *p;//指针p指向当前扫描的节点
     // int j=0；//当前p指向的是第几个节点
     int j=1；//当前p指向的是第几个节点
     p=L;//L指向头结点，头结点是第0个节点
     while (p!=NULL && j<i-1) //循环找到第i-1个结点
    {
        p=p->next;
        j++;
}
    if (p==NULL){
        return false;                          InsertNextNode(p,4) // 引用插入4的函数
    }
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s; // 将节点s连接到p之后
    return true;
}

3.指定结点的后插操作

bool InsertNextNode(LNode *p,ElemType e){
    if (p==NULL){
        return false;
    }
    LNode *s=(LNode *)malloc(sizeof(LNode));
    if(s==NULL){// 内存分配失败
        return false;
    }
    s->data=e;  // 用节点s保存数据元素e
    s->next=p->next;
    p->next=s; // 将结点s连接到p之后
    return true;
}

4.指定结点的前插操作

bool InsertPriorNode(LNode *p,ElemType e){
    if (p==NULL){
        return false;
    }
    LNode *s=(LNode *)malloc(sizeof(LNode));
    if(s==NULL){// 内存分配失败
        return false;
    }
    s->next=p->next;
    p->next=s;
    s->data=p->data;  
    p->next=e; // 将结点s连接到p之后
    return true;
}

5.按位序删除（带头结点）

bool ListDelete(LinkList &L,int i,ElemType &e){
    if (i<1)
      return false;
    LNode *p;
     int j=0；
     p=L;
     while (p!=NULL && j<i-1) //循环找到第i-1个结点
    {
        p=p->next;
        j++;
    }
    if (p==NULL){
        return false;
    }
     if (p->next==NULL){
        return false;
    }
    LNode *q=p->next;
    e=q->data;
    p->next=q->next;
    free(q);
    return true;
}

6.指定结点的删除

bool DeteleNode(LNode *p){
        if (p==NULL)
            return false;
        LNode *q=p->next;
        p->data=p->next->data;
        p->next=q->next;
        free(q);
        return true;
}

7.尾插法建立单链表

//单链表尾插法
LinkList tailInsert(LinkList& L)
{
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;
	cin >> x;
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
 
		cin >> x;
	}
	r->next = NULL;
	return L;
}

8.头插法

//单链表头插法
LinkList headInsert(LinkList& L)
{
	int x; LNode* s;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	cin >> x;
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
		cin >> x;
	}
	return L;
}

9.求长度

//单链表  计算单链表长度
int count(LinkList& L)
{
	if (L->next == NULL)
		return 0;
	int count=1;
	LNode *p=L->next;
	while (p->next)//注意是p指向空，而不是p为空
	{
		p = p->next; count++;
	}
	return count;
}

10.单链表创建带头结点

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
# define maxsize 100
typedef int ElemType;
typedef struct node
{
    int elem;
struct node *next;
}linelist;
linelist *creat()
{  int m;
  linelist *tp;
  linelist *head;
      head=new  linelist;
      head->next=NULL;
      tp=head;
   while(~scanf("%d",&m))
      {  if(m==0) break;
          linelist *p;
          p=new linelist;
        p->elem=m;
         p->next=tp->next;
         tp->next=p;
          tp=p;
      }
  return head;
}
int main()
{    int i,j;
      linelist *head;
      head=creat();
      head=head->next;
      while(head!=NULL)
      {
        printf("%d ",head->elem);
        head=head->next;
      }
    return 0;
}


11.将单链表逆序
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
# define maxsize 100
typedef int ElemType;
typedef struct node
{    int elem;
    struct node *next;
}linelist;
linelist *creat()
{  int m;
  linelist *tp;
  linelist *head;
      head=new  linelist;
      head->next=NULL;
      tp=head;
   while(~scanf("%d",&m))
      {  if(m==0) break;
          linelist *p;
          p=new linelist;
        p->elem=m;
        p->next=tp->next;
         tp->next=p;
}
 return head;
}
int main()
{    int i,j;
linelist *head;
      head=creat();
head=head->next;
      while(head!=NULL)
      {
        printf("%d ",head->elem);
        head=head->next;
      }
       return 0;
}

12.建立一个非递减有序单链表

using namespace std;
typedef struct List{
   int data;
   struct List *next;
}linelist;
void init(linelist *Head,int num){
   linelist *tp;
      linelist*now;
tp=Head;
now=Head->next;
   while(now!=NULL){
      if(num<=now->data){
           linelist *p;
           p=new linelist;
           p->data=num;
          p->next=now;
          tp->next=p;
           break;
      }
     now=now->next;
      tp=tp->next;
   }
   if(!now){
      linelist *node;
       node=new linelist;
       node->data=num;
       node->next=NULL;
        tp->next=node;
   }}
int main()
{ linelist *Head;
    Head=new linelist;
    Head->next=NULL;
    int m;
    while(~scanf("%d",&m)&&m!=0){
       init(Head,m); }
    linelist  *p;
    p=Head->next;
  while(p!=NULL){
     printf("%d ",p->data);
     p=p->next; }
  printf("\n");return 0;}

13.两个乱序单链表合并成一个有序单链表

using namespace std;
typedef int ElemType;
typedef struct node
{ int elem;
 struct node *next;
}linelist;
linelist *creat()
{  int m;
  linelist *tp;
  linelist *head;
      head=new  linelist;
      head->next=NULL;
      tp=head;
   while(~scanf("%d",&m))
      {  if(m==0) break;
          linelist *p,*pre,*p2;
          pre=head;
          p=head->next;
          while(p!=NULL&&p->elem>m)
          { pre=p;
           p=p->next;}
          p2=new linelist;
          p2->elem=m;
          p2->next=p;
          pre->next=p2;
     }
  return head;
}
void print(linelist *head)
{linelist *p;
    p=head->next;
    while(p!=NULL)
    {printf("%d ",p->elem);p=p->next;}
}
Void mergelist(linelist *head,linelist *head1,linelist *Head)
{ linelist *p1,*p2,*Head1;
    p1=head->next;
    p2=head1->next;
    Head=new linelist;
    Head1=Head;
    while(p1&&p2)
    {if(p1->elem>p2->elem)
        {Head1->next=p1;
            Head1=p1;
            p1=p1->next;
        }
        else {
           Head1->next=p2;
            Head1=p2;
            p2=p2->next;
        }}
       if(p2!=NULL)
        { Head1->next=p2; }
        if(p1!=NULL)
        { Head1->next=p1; }
print(Head);}
int main()
{linelist *p;
  linelist *head,*head1;
  head=new linelist;
  head1=new linelist;
   linelist *Head;
  head=creat();
  head1=creat();
mergelist(head,head1,Head);
    return 0;
}

14.将一个链表分解成偶数连与奇数连

#include <iostream>
using namespace std;
#include <bits/stdc++.h>
typedef struct student
{
    int data;
    struct student *next;
}stu;
void creat(stu *a,stu *b)
{int m;
 struct student *p1,*p2,*p3,*p4;
  p1=a;p3=b;
  while(~scanf("%d",&m)&&m!=0)
  {if(m%2!=0)
    {p2=(stu*)malloc(sizeof(stu));
     p2->data=m;
     p1->next=p2;p1=p2;
    }
   else if(m%2==0)
     {p4=(stu*)malloc(sizeof(stu));
       p4->data=m;
       p3->next=p4;p3=p4;
     }
  }
   p1->next=NULL;
   p3->next=NULL;

  }
void pr(stu *a)
{stu *b;
  b=a->next;
  while(b!=NULL)
  {printf("%d ",b->data);
     b=b->next;
  }
}
int main()
{int i,n;
stu *d,*b;
d=(stu*)malloc(sizeof(stu));
d->next=NULL;
b=(stu*)malloc(sizeof(stu));
b->next=NULL;
creat(d,b);
pr(d);
printf("\n");
pr(b);
    return 0;
}

带头结点的前插

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

typedef struct LNode{
   int data;
   struct LNode *next;
}LNode,*LinkList;
/*
//创造一个链表(带头结点的前插)
LNode *CreatLinkList(){
     LinkList L;
    L=(LNode*)malloc(sizeof(LNode));
   L->next=NULL;

     int x,n;
   scanf("%d",&n);
   int i=1;
   while(i<=n){
    scanf("%d",&x);i++;
    LNode *s;
    s=(LNode*)malloc(sizeof(LNode));
    s->data=x;
    s->next=L->next;
    L->next=s;

   }
   LNode *p=L->next;
   while(p!=NULL){
     printf("%d  ",p->data);
     p=p->next;
   }
    return L;


}
int main()
{
   LinkList L;

    L=CreatLinkList();


    return 0;
}
*/
//创造一个链表
LNode *CreatLinkList(LinkList &L,int x){
    LNode *s;
    s=(LNode*)malloc(sizeof(LNode));
    s->data=x;
    s->next=L->next;
    L->next=s;
    return L;


}
int main()
{
   LinkList L;

    L=(LNode*)malloc(sizeof(LNode));
   L->next=NULL;

     int x,n;
   scanf("%d",&n);
   int i=1;
   while(i<=n){
    scanf("%d",&x);i++;
    L=CreatLinkList(L,x);
   }
 LNode *p=L->next;
   while(p!=NULL){
     printf("%d  ",p->data);
     p=p->next;
   }
    return 0;
}

带头结点的尾插

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

typedef struct LNode{
   int data;
   struct LNode *next;
}LNode,*LinkList;
//创造一个链表(带头结点的尾插)
LNode *CreatLinkList(){
     LinkList L;
    L=(LNode*)malloc(sizeof(LNode));
   L->next=NULL;
    LinkList p;
    p=L;
     int x,n;
   scanf("%d",&n);
   int i=1;
   while(i<=n){
    scanf("%d",&x);i++;
    LNode *s;
    s=(LNode*)malloc(sizeof(LNode));
    s->data=x;
    s->next=p->next;
    p->next=s;

    p=s;
   }
   LNode *q=L->next;
   while(q!=NULL){
     printf("%d  ",q->data);
     q=q->next;
   }
    return L;


}
int main()
{
   LinkList L;

    L=CreatLinkList();


    return 0;
}

不带头结点的尾插

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

typedef struct LNode{
   int data;
   struct LNode *next;
}LNode,*LinkList;
//创造一个链表(不带头结点的尾插)
LNode *CreatLinkList(){
     LinkList L;
    L=(LNode*)malloc(sizeof(LNode));
    L=NULL;
    LinkList p;
    p=L;
    int x,n;
   scanf("%d",&n);
   int i=1;
   while(i<=n){
    scanf("%d",&x);i++;
    LNode *s;
    s=(LNode*)malloc(sizeof(LNode));
    s->data=x;
    if(p==NULL){
        L=s;
        p=s;

    }
    else{
        p->next=s;
        p=s;
        s->next=NULL;
    }
   }
   LNode *q=L;
   while(q!=NULL){
     printf("%d  ",q->data);
     q=q->next;
   }
    return L;


}
int main()
{
   LinkList L;

    L=CreatLinkList();


    return 0;
}

不带头结点的头插

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

typedef struct LNode{
   int data;
   struct LNode *next;
}LNode,*LinkList;
//创造一个链表(不带头结点的头插)
LNode *CreatLinkList(){
     LinkList L;
    L=(LNode*)malloc(sizeof(LNode));
    L=NULL;
    int x,n;
   scanf("%d",&n);
   int i=1;
   while(i<=n){
    scanf("%d",&x);i++;
    LNode *s;
    s=(LNode*)malloc(sizeof(LNode));
    s->data=x;
    s->next=L;
    L=s;

   }
   LNode *q=L;
   while(q!=NULL){
     printf("%d  ",q->data);
     q=q->next;
   }
    return L;


}
int main()
{
   LinkList L;

    L=CreatLinkList();


    return 0;
}
张张同学！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
王道考研数据结构单链表代码（带头节点）
05-28
自己写的王道考研数据结构单链表（带头结点）例题和习题代码，所有函数运行都没问题。
数据结构2-链表
m0_70983574的博客
06-19 661
关于线性表-链表的一些基本操作
王道数据结构精简笔记——单链表
weixin_53830825的博客
07-10 334
/ 定义单链表结点类型（结点） ElemType data;// 每个结点存放一个数据元素（数据域） struct LNode * next;// 指针指向下一个结点（指针域） } LNode , * LinkList;// LinkList是指向结构体首地址的指针使用LinkList：强调这是一个单链表；使用LNode *：强调这是一个结点；
【数据结构】【王道】【线性表】单链表的实现及基本操作（带头结点）（可直接运行）
treesorshining的博客
07-11 1676
1.2 初始化 1.3 判空 1.4 按位序插入 1.5 指定结点后插操作 1.6 指定结点前插操作 1.7 按位序删除 1.8 按位查找 1.9 按值查找 1.10 表的长度 1.11 单链表建立（尾插法） 1.12 单链表建立（头插法） 1.13 输出所有链表元素 2.完整代码 3.运行截图............
链表中的LinkList L、LinkList *L
ShenHang_的博客
06-09 3224
对于LinkList L: L是指向定义的node结构体的指针,可以用->运算符来访问结构体成员,即L->elem,而(*L)就是个Node型的结构体了,可以用点运算符访问该结构体成员,即(*L).elem; 对于LinkList *L:L是指向定义的Node结构体指针的指针,所以(*L)是指向Node结构体的指针,可以用->运算符来访问结构体成员,即(*L)->elem,...
王道考研数据结构——链表
Tandy12356_的博客
07-24 188
考研当中链表的相关内容
王道考研数据结构单链表代码（不带头节点）
05-28
自己写的王道考研数据结构单链表（不带头结点）例题和习题代码，所有函数运行都没问题。
王道2019数据结构
01-06
王道数据结构2019，c语言，pdf.
王道机试指南.rar
02-10
王道技术指南源码cpp文件，很全，复试上机准备可用。
数据结构--单链表（带头结点）（王道408数据结构）
东路的博客
10-20 1563
带头结点单链表操作及实现前言一、带头结点单链表1.单链表定义二、单链表特征三、单链表基本操作（带头结点）1.初始化单链表2.求链表表长3.采用头插法建立单链表（带头结点）4.采用尾插法建立单链表（带头结点）5.按位置序号查找结点值6.按值查找结点值7.后插操作，在节点p之后插入元素e8.带头节点的插入操作，在第i个位置插入元素e9.在第一个元素e的后边插入元素x10.前插操作，在p节点前插入元素e11.前插操作，在节点p之前插入节点s12.带头节点的前插操作，在第i个位置前插入元素e12.删除节点操作13.
23王道——单链表
下次再说的博客
03-14 1464
#include<iostream>
链表中p->next=head->next;语句解析
热门推荐
浅然的专栏
09-30 3万+
在看到一些书上或者网上写的不管是单链表还是双向循环链表等，都会有p->next=q->next;或者p-next=head->next; 这里q是尾指针，head是头指针，p是指向新建结点的指针 该语句作用 这条语句的作用其实就是给新建结点找到它该有的位置 该语句在单链表下的头插法是必须存在的，而在双向循环下可有可无1.单链表的头插法下p-next=head->next;LinkLis
单链表的基本操作
傻红就是不爱跑步的博客
03-28 289
#include <stdio.h> #include <stdlib.h>struct Linklist{ char data; struct Linklist * next; }; Linklist * createLinklist(){ Linklist * head,* p; char x; head = (Linklist *)malloc(size
编写算法函数linklist delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。
linjiajun12123的博客
11-04 7339
/* 编写算法函数linklist delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。 */ linklist delallx(linklist head,int x) {    linklist p=head->next,q=NULL;    while(p!=NULL)    {        while(p->info!
转——链表中LinkList L与LinkList *L的区别
weixin_30457551的博客
12-09 5504
typedef struct Node{ int elem; struct node * next; }node,*LinkList; 　　 对于LinkList L: L是指向定义的node结构体的指针,可以用->运算符来访问结构体成员,即L->elem,而(*L)就是个Node型的结构体了,可以用点运算符访问该结构体成员,即(*L).elem; 对于Link...
SlinkList（不带头节点的单链表）20171003
学无止境，Fighting！
10-03 473
#include typedef int Datatype; typedef struct link_node { Datatype info; struct link_node *next; }node; node *init(node *head) { return NULL; } void display(node *head) { if (!head
LinkList
默默的小熊
09-02 115
  public class LinkList { private Node firstNode; //head private Node currentLastNode;//tail private int size = 0; /*public void add(Object o) { if (firstNode == null) { Node n = new...
链表的头插法
qiqisunshine的博客
08-12 1160
没想到一个看似简单的链表的头插法……昨天我竟然写了一个多小时……而且最后还不对……大话数据结构只有函数部分，主函数是怎么调用的并没有写，可能大部分人都觉得都已经把最难的部分写出来了，没必要都写全，可是每一部分对我来说都很难……九月份就找工作了对自己表示担忧。。。 主函数在调用createLink（）函数时，createLink里有两个参数，对于第一个参数的传入有两种写法： 1、Linklist
408王道pdf2024
最新发布
11-02
408王道是一套备受推崇的高中物理辅导资料，其中的PDF版本对于许多学生来说是非常实用和方便的资源。408王道的PDF版本为学生提供了电子化的学习资料，可以在电脑、手机或平板电脑上方便地查阅和学习。 PDF格式的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值