单链表的基本操作

于 2023-03-18 22:09:36 发布
阅读量481 收藏 8
点赞数 1
分类专栏： 数据结构 文章标签： c++ 算法 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62949330/article/details/129643833
版权

第1关：单链表的插入操作

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

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
/* 单链表类型定义 */
typedef struct LNnode
{    
    ElemType data;
    struct LNnode *next;
}LNnode,*LinkList;

void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));

int main()               //main() function 
{    
     LinkList A;
     ElemType e;
     InitList(A);
      int n,i;
     // cout<<"Please input the list number ";
     cin>>n;
     for(i=1;i<=n;i++)
        { 
           cin>>e;
         ListInsert(A, i, e);
       }
    //cout<<"请输入插入的位置："<<endl;
    cin>>i;
    //cout<<"请输入插入的值："<<endl;
    input(e);
    if(  ListInsert(A,i,e) )
    {
      cout<<"插入成功，插入后单链表如下："<<endl;
      ListTraverse(A,output) ;
    }
    else
        cout<<"插入位置不合法，插入失败！"<<endl;
    return  0;  
 }


/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
cin>>s;
}
void output(ElemType s)
 {
cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
    if(a==b)
        return  1;
    else
        return  0;
}

/*****单链表的基本操作*****/
void InitList(LinkList &L)
{ 
    // 操作结果：构造一个空的单链表L
    /********** Begin **********/ 
    L=(LinkList)malloc(sizeof(LNnode)); 
    if(!L) 
    {
        L->next=NULL;      
    }
}                           
    
    
    /********** End **********/
int ListInsert(LinkList &L,int i,int e) 
{
    // 在带头结点的单链线性表L的第i个元素之前插入元素e  
    /********** Begin **********/ 
    int j=0;
    LinkList p=L,s;
    while( p && j<i-1 )                  // p指向第i-1个结点
    {
        p=p->next;
        j++;
    }
    if(!p || j>i-1) 
         return 0;

                    // i小于1或者大于表长
       
    s=(LinkList)malloc(sizeof(LNnode));   // s指向新生成的结点
    s->data=e;                           // 将e存入新结点的数据域
    s->next=p->next;                     // ①新结点s的指针域指向第i个结点
    p->next=s;                 

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

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 
    // 初始条件：单链表L已存在。
    //操作结果：依次对L的每个数据元素调用函数vi()
    /********** Begin **********/ 
   LinkList p=L->next;   //p指向单链表第一个结点
   while( p )
   {
     vi(p->data);
     p = p->next;
   }
    /********** End **********/
}

第2关：单链表的删除操作

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

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);

/* 单链表类型定义 */
typedef struct LNnode
{    
    ElemType data;
    struct LNnode *next;
}LNnode,*LinkList;

void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
int ListDelete(LinkList L,int i,ElemType &e);
void ListTraverse(LinkList L,void(*vi)(ElemType));

int main()               //main() function 
{    
    LinkList A;
    ElemType e;
    InitList(A);
    int n,i;
    // cout<<"Please input the list number ";
    cin>>n;
    for(i=1;i<=n;i++)
    { 
        cin>>e;
        ListInsert(A, i, e);
    }
    //cout<<"请输入删除的位置："<<endl;
    cin>>i;    
    if(  ListDelete(A,i,e) )
    {
        cout<<"删除成功，删除后单链表如下："<<endl;
        ListTraverse(A,output) ;
        cout<<"删除元素的值：";
       output(e);
          cout<<endl;
    }
    else
        cout<<"删除位置不合法，删除失败！"<<endl;
}



/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
    cin>>s;
}
void output(ElemType s)
{
    cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
    if(a==b)
        return  1;
    else
        return  0;
}

/*****单链表的基本操作*****/
void InitList(LinkList &L)
{     // 构造一个空的单链表L    
    L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
    if(!L) // 存储分配失败
        return ;
    L->next=NULL; // 指针域为空
    
}

int ListInsert(LinkList &L,int i,ElemType e) 
{    // 在带头结点的单链线性表L的第i个元素之前插入元素e  
    LinkList p,s;
    p = L;   
    int j = 0;
    while (p && j < i-1) {  // 寻找第i-1个结点
        p = p->next;
        ++j;
    } 
    if (!p || j > i-1) 
        return 0;                   // i小于1或者大于表长
    s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
    s->data = e;  s->next = p->next;      // 插入L中
    p->next = s;
    return 1;
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{     // 调用函数vi()依次输出单链表L的每个数据元素
    LinkList p=L->next;
    while(p)
    {
        vi(p->data);
        p=p->next;
    }
    printf("\n");    
}

int  ListDelete(LinkList L,int i,ElemType &e) // 算法2.10。不改变L
{ 
    // 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
    /********** Begin **********/ 
    LinkList p=L;
    int n=0;
    if(i<1)
    return 0;
    while(p->next!=NULL && n<i-1)
    {
        n++;
        p=p->next;
    } 
   if(p->next==NULL)
   return 0;
    LNnode *q=p->next;
    e=q->data;
    p->next=q->next;
   
    return 1;

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

第3关：单链表的按照序号查找值操作

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

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);

/* 单链表类型定义 */
typedef struct LNnode
{    
    ElemType data;
    struct LNnode *next;
}LNnode,*LinkList;

void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
int GetElem(LinkList L,int i,ElemType &e) ;

int main()               //main() function 
{    
    LinkList A;
    ElemType e;
    InitList(A);
    int n,i;
    // cout<<"Please input the list number ";
    cin>>n;
    for(i=1;i<=n;i++)
    { 
        cin>>e;
        ListInsert(A, i, e);
    }
    //cout<<"请输入查找的序号："<<endl;
    cin>>i;    
    if(  GetElem(A,i,e) )
    {
        cout<<"查找成功！"<<endl;
        cout<<"第"<<i<<"个元素的值："<<endl;
        output(e);
        cout<<endl;
    }
    else
        cout<<"查找失败！"<<endl;
}

/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
    cin>>s;
}
void output(ElemType s)
{
    cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
    if(a==b)
        return  1;
    else
        return  0;
}

/*****单链表的基本操作*****/
void InitList(LinkList &L)
{     // 操作结果：构造一个空的单链表L
    L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
    if(!L) // 存储分配失败
        return ;
    L->next=NULL; // 指针域为空
    
}

int ListInsert(LinkList &L,int i,ElemType e) 
{    // 在带头结点的单链线性表L的第i个元素之前插入元素e  
    LinkList p,s;
    p = L;   
    int j = 0;
    while (p && j < i-1) {  // 寻找第i-1个结点
        p = p->next;
        ++j;
    } 
    if (!p || j > i-1) 
        return 0;                   // i小于1或者大于表长
    s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
    s->data = e;  s->next = p->next;      // 插入L中
    p->next = s;
    return 1;
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{     // 初始条件：单链表L已存在。
    //操作结果：依次对L的每个数据元素调用函数vi()
    LinkList p=L->next;
    while(p)
    {
        vi(p->data);
        p=p->next;
    }
    printf("\n");
}

int GetElem(LinkList L,int i,ElemType &e) 
{ 
    // L为带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回1，否则返回0
    /********** Begin **********/ 
    int j=0;
    LinkList p=L;
    while(p && j<i)
    {
      
      p=p->next;
      ++j;
    }
    if(!p || j>i)
    return 0;
    e=p->data;
    return 1;
    /********** End **********/
}

第4关：单链表的按照值查找结点位序的操作

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


/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);

/* 单链表类型定义 */
typedef struct LNnode
{    
    ElemType data;
    struct LNnode *next;
}LNnode,*LinkList;
void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
int LocateElem(LinkList L,ElemType e,int(*compare)(ElemType,ElemType));
int main()               //main() function 
{    
    LinkList A;
    ElemType e;
    InitList(A);
    int n,i;
    // cout<<"Please input the list number ";
    cin>>n;
    for(i=1;i<=n;i++)
    { 
        cin>>e;
        ListInsert(A, i, e);
    }
    //cout<<"请输入查找的元素："<<endl;
    cin>>e;    
    i=LocateElem(A,e,equals);
    if( i ) 
    {
        cout<<"查找成功！"<<endl;        
        output(e);
      cout<<"是单链表第"<<i<<"个元素"<<endl;
    }
    else
        cout<<"查找失败！"<<endl;
}



/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
    cin>>s;
}
void output(ElemType s)
{
    cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
    if(a==b)
        return  1;
    else
        return  0;
}

/*****单链表的基本操作*****/
void InitList(LinkList &L)
{     // 操作结果：构造一个空的单链表L
    L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
    if(!L) // 存储分配失败
        return ;
    L->next=NULL; // 指针域为空    
}

int ListInsert(LinkList &L,int i,ElemType e) 
{    // 在带头结点的单链线性表L的第i个元素之前插入元素e  
    LinkList p,s;
    p = L;   
    int j = 0;
    while (p && j < i-1) {  // 寻找第i-1个结点
        p = p->next;
        ++j;
    } 
    if (!p || j > i-1) 
        return 0;                   // i小于1或者大于表长
    s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
    s->data = e; 
    s->next = p->next;      // 插入L中
    p->next = s;
    return 1;    
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{     // 初始条件：单链表L已存在。
    //操作结果：依次对L的每个数据元素调用函数vi()
    LinkList p=L->next;
    while(p)
    {
        vi(p->data);
        p=p->next;
    }
    printf("\n");
}

int LocateElem(LinkList L,ElemType e,int (*equal)(ElemType,ElemType))
{ 
    // 初始条件: 单链表L已存在，equal()是数据元素判定函数(满足为1，否则为0)
    // 操作结果: 返回L中第1个与e满足关系equal()的数据元素的位序，若这样的数据元素不存在，则返回值为0
    /********** Begin **********/ 
    LinkList p=L->next;
    int n=0;
    while(p->next)
    {
        n++;
        if(equal(e,p->data))
        return n;
        p=p->next;
    }
    return 0;
    /********** End **********/
}

第5关：单链表的逆置操作

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

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);

/* 单链表类型定义 */
typedef struct LNnode
{    
    ElemType data;
    struct LNnode *next;
}LNnode,*LinkList;
void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
void reverse (LinkList  L);
int main()               //main() function 
{    
    LinkList A;
    ElemType e;
    InitList(A);
    int n,i;
    // cout<<"Please input the list number ";
    cin>>n;
    for(i=1;i<=n;i++)
    { 
        cin>>e;
        ListInsert(A, i, e);
    }
    cout<<"逆置单链表："<<endl;
    reverse(A);
    ListTraverse(A,output) ;    
}

/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
    cin>>s;
}
void output(ElemType s)
{
    cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
    if(a==b)
        return  1;
    else
        return  0;
}

/*****单链表的基本操作*****/
void InitList(LinkList &L)
{     // 操作结果：构造一个空的单链表L
    L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
    if(!L) // 存储分配失败
        return ;
    L->next=NULL; // 指针域为空    
}

int ListInsert(LinkList &L,int i,ElemType e) 
{    // 在带头结点的单链线性表L的第i个元素之前插入元素e  
    LinkList p,s;
    p = L;   
    int j = 0;
    while (p && j < i-1) {  // 寻找第i-1个结点
        p = p->next;
        ++j;
    } 
    if (!p || j > i-1) 
        return 0;                   // i小于1或者大于表长
    s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
    s->data = e;  s->next = p->next;      // 插入L中
    p->next = s;
    return 1;    
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{     // 初始条件：单链表L已存在。
    //操作结果：依次对L的每个数据元素调用函数vi()
    LinkList p=L->next;
    while(p)
    {
        vi(p->data);
        p=p->next;
    }
    printf("\n");    
}

void reverse (LinkList  L)
{  
    //逆置L指针所指向的单链表
    /********** Begin **********/ 
    LinkList p=L->next;
    LinkList m;
    L->next=NULL;
    while(p)
    {
        m=p;
        p=p->next;
        m->next=L->next;
        L->next=m;

    }


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

第6关：两个有序单链表的合并操作

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

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);

/* 单链表类型定义 */
typedef struct LNnode
{    
    ElemType data;
    struct LNnode *next;
}LNnode,*LinkList;
void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc);

int main()               //main() function 
{    
    LinkList A,B,C;
    ElemType e;
    InitList(A);
    InitList(B);
    int n,i;
    // cout<<"Please input the list number ";
    cin>>n;
    for(i=1;i<=n;i++)
    { 
        cin>>e;
        ListInsert(A, i, e);
    }
    cin>>n;
    for(i=1;i<=n;i++)
    { 
        cin>>e;
        ListInsert(B, i, e);
    }
    cout<<"合并两个有序单链表："<<endl;
    MergeList(A,B,C);    
    ListTraverse(C,output) ;    
}

/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
    cin>>s;
}
void output(ElemType s)
{
    cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
    if(a==b)
        return  1;
    else
        return  0;
}

/*****单链表的基本操作*****/
void InitList(LinkList &L)
{     // 操作结果：构造一个空的单链表L
    L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
    if(!L) // 存储分配失败
        return ;
    L->next=NULL; // 指针域为空    
}

int ListInsert(LinkList &L,int i,ElemType e) 
{    // 在带头结点的单链线性表L的第i个元素之前插入元素e  
    LinkList p,s;
    p = L;   
    int j = 0;
    while (p && j < i-1) {  // 寻找第i-1个结点
        p = p->next;
        ++j;
    } 
    if (!p || j > i-1) 
        return 0;                   // i小于1或者大于表长
    s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
    s->data = e;  s->next = p->next;      // 插入L中
    p->next = s;
    return 1;    
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{     // 初始条件：单链表L已存在。
    //操作结果：依次对L的每个数据元素调用函数vi()
    LinkList p=L->next;
    while(p)
    {
        vi(p->data);
        p=p->next;
    }
    printf("\n");    
}

void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc) 
{
    // 已知单链线性表La和Lb的元素按值非递减排列。
    // 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列。
    /********** Begin **********/ 
    LinkList pa=La->next;
    LinkList pb=Lb->next;
    LinkList pc;
    Lc=La;
    pc=Lc;
    while(pa && pb)
    {
        if(pa->data>=pb->data)
        {
            pc->next=pb;
            pc=pb;
            pb=pb->next;

        }
        else
        {
            pc->next=pa;
            pc=pa;  
            pa=pa->next;
        }
    }
    if(pa)
    {
        pc->next=pa;
    }
    else
    pc->next=pb;
    
    /********** End **********/
}
ଲଇଉକ ଲ ̊ଳ
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【头歌】单链表的基本操作
qq_39977056的博客
01-23 1万+
由于单链表中每个结点的存储地址是存放在其前趋结点的指针域中的，而第一个结点无前趋，头指针L指向第一个结点，对于整个单链表的读取必须从头指针开始，同时，由于单链表中最后一个结点的指针域为“空”（NULL），没有直接后继元素，对于整个单链表的读取必须在尾结点结束。要在带头结点的单链表L中删除第i个结点，则同样要先找到第i-1个结点，使p指向第i-1个结点，使q指向第i个结点，然后令第i-1个结点的指针域指向第i+1个结点，而后删除q指向的第i个结点并释放结点空间。= NULL时，才能进行删除结点的操作。
数据结构之单链表在第i个元素之前插入元素的算法
weixin_34015860的博客
01-04 7058
     数据结构之单链表区第i个元素的算法算法思路：  1.声明一个结点p指向第一个结点，初始化j从1开始  2.当j&lt;i时就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1  3.若到链表末尾p为空，则说明第i个元素不存在  4.否则查找成功，在系统中生成一个空结点  5.将数据元素e赋给s-&gt;data  6.返回成功     单链表的数据结构：  typedef in...
数据结构笔记——线性表
Wmiracle的博客
10-30 1060
本篇学习笔记包含线性表的定义以及顺序表、链表的代码实现，内容综合各方资料及本人的理解将线性表最基础的理论整合而成。
单链表的相关操作
WWWANGLE的专栏
11-30 536
#include /* malloc()等 */ #include /* EOF(=^Z或F6),NULL */ #include /* atoi() */ #include /* eof() */ #include /* floor(),ceil(),abs() */ #include /* exit() */ /* 函数结果状态代码 */ #define TRUE 1 #def
严蔚敏C语言版的单链表删除操作（纯敲代码）——中职
乖珑珑的博客
01-19 623
严蔚敏C语言版的删除操作 /* 严蔚敏数据结构C语言版 P30 算法2.10 在带头结点的单链线性表L中，删除第i个元素 */ //头文件 #include<stdio.h> #include<malloc.h> #include<stdlib.h> //结构 typedef struct LIST //该链表的结构 { int data; //该单链表的数据域 struct LIST *NEXT;
数据结构(C语言版 严蔚敏著)——线性表
Super_Sloppy的博客
10-11 1238
线性表定义：由零个或多个数据元素组成的有限序列。 · 需注意几个关键点： -它是一个序列，也就是说元素之间是有先来后到的。 -若元素存在多个，则第一个元素无前驱，而最后一个元素无后继，其他元素有且只有一个前驱和一个后继。 -线性表强调是有限的，无论计算机发展到多强大，它所处理的元素是有限的。   如果用数学语言来定义，可如下定义： · 若将线性表记为（a1，...，ai-1，ai，a...
单链表基本操作.rar
04-01
这个压缩包文件“单链表基本操作.rar”包含了一个名为“单链表基本操作.docx”的文档，我们可以从中学习到关于单链表的各种核心概念和操作。 单链表是由一系列节点构成的线性数据结构，每个节点包含两部分：数据域...
单链表基本操作
08-25
单链表 基本操作
基于Java实现的单链表基本操作之链表排.zip
最新发布
04-26
在这个基于Java实现的单链表基本操作项目中，我们主要关注的是链表的排序。下面将详细讲解单链表的基本概念、Java中如何实现单链表以及如何进行链表排序。 **一、单链表的基本概念** 单链表是由一系列节点组成的...
基于Java实现的单链表基本操作之链表合并.zip
04-26
本项目聚焦于Java实现的单链表基本操作，特别是链表的合并这一关键操作。下面将详细介绍单链表的概念、基本操作以及如何在Java中实现链表合并。 单链表是一种线性数据结构，每个节点包含两部分：数据域，用于存储...
第1关：有序单链表的插入操作【头歌】
shaojiuli的博客
05-01 2472
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.
数据结构之单链表删除第i个元素并用e返回其值的算法
weixin_33894640的博客
01-04 4124
数据结构之单链表区第i个元素的算法算法思路：1.声明一个结点p指向第一个结点，初始化j从1开始2.当j<i时就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加13.若到链表末尾p为空，则说明第i个元素不存在4.否则查找成功，将欲删除的结点p->pNext赋值给q5.将q结点数据赋给e6.释放q结点7.返回成功单链表的数据结构：typede...
有序单链表的插入删除操作
qq_45917176的博客
06-30 3102
数据结构--有序单链表的插入删除操作
单链表的查找（按序号，按值查找）
apple_2021的博客
07-31 1万+
单链表的查找操作 一. 按序号查找 #include<iostream> using namespace std; typedef struct LNode { int data; struct LNode *next; } *LinkList,LNode; // 尾插建立单链表 LinkList List_ToolInsert (LinkList &L){ int x; L = (LinkList)malloc (sizeof(LNode)); LNode *s,*r =
单链表的插入操作（全）
热门推荐
Boyt1317的博客
05-04 2万+
单链表的插入（全） 三种方式进行插入操作
【头歌】顺序表的基本操作
qq_39977056的博客
01-23 1万+
时，在函数体内不需要改变主调函数中的实参变量的值，只需读取主调函数中的实参变量的值，因此函数形参定义为变量，采用值传递。，i-1上的结点，依次后移到位置n，n-1，…关于逆置，有一种非常暴力的解决方法，就是单独开辟一个同等大小的顺序表，然后新表从前往后遍历，同时原表从后往前遍历，依次赋值，最后得到的就是逆置后的顺序表。，ai−1，ai，ai+1，…顺序表的就地逆置，只需让顺序表中的数据元素头尾依次交换即可，即交换第一个元素和最后一个元素，第二个和倒数第二个，依此类推，这种方法的空间复杂度为O(1)。
单链表基本操作的实现
09-29
以下是单链表基本操作的实现代码： ```c /* 初始化链式线性表 */ Status IniList(LinkList *L) { *L = (LinkList)malloc(sizeof(Node)); /* 产生头结点，并使L指向此头结点 */ (*L)->next = NULL; /* 指针域为空 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ଲଇଉକ ଲ ̊ଳ

多谢大哥赏赐

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值