精华内容
下载资源
问答
  • 单链表插入 链表插入节点 单链表删除节点 链表删除节点 链表输出 链表输...

    单链表插入

    链表插入节点

    单链表删除节点

    链表删除节点

    链表输出

    链表输出

    链表释放内存空间

    链表释放内存空间

    展开全文
  • 单链表插入删除.c

    2019-09-27 17:34:28
    实现单链表的建立、结点的插入删除操作,上机调试程序直到算法运行正确
  • 单链表插入删除操作的时间复杂度

    千次阅读 2019-11-10 10:31:23
    单链表相比数组的优势在于插入删除元素快,不需要移动大量的元素,只需要改变指针的指向,那么插入删除操作的时间复杂度应该是O(1),但是这是不对的,应该分情况讨论。 单链表结构体声明: typedefstruct LNode { ...

    单链表相比数组的优势在于插入删除元素快,不需要移动大量的元素,只需要改变指针的指向,那么插入删除操作的时间复杂度应该是O(1),但是这是不对的,应该分情况讨论。

    单链表结构体声明:

    typedefstruct LNode
    {
        ElemType data;
        struct LNode *next;
    }LNode,*LinkList;
    

    O(n)的情况

    1. 一个已知头结点的链表(假设足够长),删除第index个元素。
      首先我们需要从头开始向后遍历,直到找到第index-1个结点,这需要O(n)时间;找到以后,改变指针的指向,这需要O(1)的时间。时间复杂度为O(n)。
    LinkListhead;
    LinkListp=head;
    inti=0;
    while(p&&i<=index-2)//找到第index-1个结点退出
    {
        p=p->next;
        i++;
    }
    LinkListq=p->next;//q是第index个节点,即要删除的节点
    p->next=q->next;//转移指针
    free(q);//释放内存<pre name="code" class="cpp">LinkListnewnode=(LinkList)malloc(sizeof(LNode));
    newnode->data=newdata;
    newnode->next=node->next;
    node->next=newnode;
    q=NULL;//指向空指针
    

    2.一个已知头结点的链表(假设足够长),在第index个元素前插入一个元素。
    首先我们需要从头开始向后遍历,直到找到第index-1个结点,这需要O(n)时间;找到以后,创建新节点,改变指针的指向,这需要O(1)的时间。时间复杂度为O(n)。

    LinkList head;
    LinkList p=head;
    int i=0;
    while(p&&i<=index-2)
    {
       p=p->next;
        i++;
    }
    LinkList newnode=(LinkList)malloc(sizeof(LNode));
    newnode->data=newdata;
    newnode->next=p->next;
    p->next=newnode;
    

    O(1)的情况
    1.) 一个已知头结点的链表(假设足够长),删除某结点,且告诉你该元素的地址node(struct LNode*类型)。
    由于这是单链表,我们无法获取node前一个节点的地址,因此好像不能删除这个结点。但是在我们看来,是否删除这个节点只是看这个节点的data值是否还存在于链表中,因此,我们可以让链表看起来删除了node,实则删除了结点node->next.

    LinkListnode1=node->next;
    node->data=node1->data;//移交元素
    node->next=node1->next;//移交指针
    free(node2);//释放目标删除结点后一个节点的内存
    node2=NULL;//置空指针
    

    看似删除node结点,实际上node->next成了真正的牺牲品。上述操作在O(1)内完成。
    2.) 一个已知头结点的链表(假设足够长),在某结点后面插入新节点,大小为newdata,且告诉你该结点的地址node(struct LNode *类型)。

    LinkListnewnode=(LinkList)malloc(sizeof(LNode));
    newnode->data=newdata;
    newnode->next=node->next;
    node->next=newnode;
    

    时间复杂度:O(1)

    展开全文
  • 包括单链表插入 删除 修改 以及插入 删除的动态演示
  • 单链表插入删除操作

    2018-03-31 17:17:37
    #include&lt;iostream&gt; using namespace std; typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; int InitList(LinkList &amp;L) { L=new LNode;... L-...
    #include<iostream>
    using namespace std;
    
    typedef struct LNode
    {
        int data;
        struct LNode *next;
    }LNode,*LinkList;
    
    int InitList(LinkList &L)
    {
        L=new LNode;      //生成新结点作为头结点
        L->next=NULL;      //头结点的指针域置空
        return 1;
    }
    
    void CreateList(LinkList &L,int n)  //尾插法输入链表,采用头插法输入的链表输出为逆序
    {
        LinkList r,p;
        L=new LNode;
        L->next=NULL;
        r=L;
        for(int i=0;i<n;i++)
        {
            p=new LNode;
            cin>>p->data;
            p->next=NULL;
            r->next=p;
            r=p;
        }
    }
    
    int LinkInsert(LinkList &L,int i,int e)
    {
        LinkList p,s;
        p=L;
        int j=0;
        while(p&&(j<i-1))
        {
            p=p->next;
            ++j;
        }
        if(!p||j>i-1) return 0;
        s=new LNode;
        s->data=e;
        s->next=p->next;
        p->next=s;
        return 1;
    }
    
    int LinkDelete(LinkList &L,int i)
    {
        LinkList p,q;
        int j=0;
        p=L;
        while((p->next)&&(j<i-1))
        {
            p=p->next;
            ++j;
        }
        if(!(p->next)||(j>i-1)) return 0;
        q=p->next;
        p->next=q->next;
        delete q;
        return 1;
    }
    
    int prin(LinkList &L)
    {
        LinkList p;
        p=L->next;
        while(p)
        {
            cout<<p->data<<' ';
            p=p->next;
        }
        cout<<endl;
    }
    
    int main()
    {
        LNode *Pa;
        InitList(Pa);
        CreateList(Pa,5);
        prin(Pa);
        LinkInsert(Pa,4,8);
        prin(Pa);
        LinkDelete(Pa,4);
        prin(Pa);
    
        return 0;
    }

    展开全文
  • 数据结构之单链表插入删除操作

    千次阅读 2018-10-30 13:07:11
    #include&lt;iostream&gt; using namespace std; typedef struct LNode { int data; struct LNode *next;...void createListR(LNode *C, int a[]...//尾插法建立单链表 void createListF(LNode *C, int a[], ...
    #include<iostream>
    using namespace std;
    typedef struct LNode {
    	int data;
    	struct LNode *next;
    }LNode;
    void createListR(LNode *C, int a[], int n);//尾插法建立单链表
    void createListF(LNode *C, int a[], int n);//头插法建立单链表
    void traversal(LNode *C);
    int getLength(LNode *C);
    void deleteLNode(LNode *C,int n,int l);//删除第n项
    void  insertLNodeR(LNode *C, int n, int e,int l);//在第n处尾插法插入数字e
    int main() {
    	LNode *C;
    	C = (LNode *)malloc(sizeof(LNode));//C为头指针,并且指向头结点
    	C->next = NULL;
    	int a[6] = { 1,2,3,4,5,6 };
    	/创建单链表
    	createListF(C, a, 4);
    	traversal(C);
    	cout << "该单链表长度为:" << getLength(C) << endl;
    	插入
    	insertLNodeR(C, 3, 999, getLength(C));
    	traversal(C);
    	cout << "该单链表长度为:" << getLength(C) << endl;
    	删除
    	deleteLNode(C, 2, getLength(C));
    	traversal(C);
    	cout << "该单链表长度为:" << getLength(C) << endl;
    	///
    	return 0;
    }
    void createListR(LNode *C, int a[], int n) {
    	LNode *s, *r;//s用来接收新结点,r用来始终指向终端结点
    	r = C;
    	for (int i = 0; i < n;++i) {
    		s = (LNode *)malloc(sizeof(LNode));
    		s->data = a[i];
    		//关键步骤
    		r->next = s;
    		r = r->next;//尾指针后移
    		//关键步骤
    	}
    	r->next = NULL;
    }
    void createListF(LNode *C, int a[], int n) {
    	LNode *s;
    	for (int i = 0; i < n; ++i) {
    		s = (LNode *)malloc(sizeof(LNode));
    		s->data = a[i];
    		//关键步骤
    		s->next = C->next;
    		C->next = s;
    		//关键步骤
    	}
    }
    void traversal(LNode *C) {
    	LNode *p;//用来指向头结点
    	p = C;
    	cout << "遍历结果为:";
    	while ( (p->next)!=NULL ){
    		p = p->next;//p指针后移
    		cout << p->data << "   ";
    	}
    	cout << endl;
    }
    int getLength(LNode *C) {
    	LNode *p;
    	p = C;
    	int l = 0;
    	while ((p->next) != NULL) {
    		++l;
    		p = p->next;
    	}
    	return l;
    }
    void deleteLNode(LNode *C, int n,int l) {
    	LNode *p;
    	LNode *q;
    	p = C;
    	int m = 0;
    	p = C;
    	if (n<1 || n>l) {
    		cout << "没有该项数!" << endl;
    	}
    	else {
    		while (m<n-1) {
    			p = p->next;
    			++m;
    		}
    		//关键部分
    		q = p->next;
    		p->next=p->next->next;
    	  //关键部分
    		cout << "删除第" << n << "个数字" << endl;
    		cout << "删除的数字是:" << q->data << endl;
    	}
    }
    void insertLNodeR(LNode *C, int n, int e, int l) {
    	LNode *p;
    	LNode *s;//接收新结点
    	s = (LNode *)malloc(sizeof(LNode));
    	s->data = e;
    	p = C;
    	int m = 0;
    	if (n<1 || n>l) {
    		cout << "插入位置不合法!" << endl;
    	}
    	else {
    		while (m<n ) {//若在插入位置之前插入数字,改为m<n-1
    			p = p->next;
    			++m;
    		}
    		s->next=p->next;
    		p->next = s;
    	}
    	cout << "在第" << n << "处后" << "插入数字" << e << endl;
    }
     

     

    展开全文
  • 单链表插入删除元素时间复杂度探究

    万次阅读 多人点赞 2015-03-26 00:50:07
    单链表相比数组的优势在于插入删除元素快,不需要移动大量的元素,只需要改变指针的指向,那么插入删除操作的时间复杂度应该是O(1),但是这是不对的,应该分情况讨论。 单链表结构体声明: typedefstruct LNode { ...
  • https://blog.csdn.net/qq_44024359/article/details/102995080
  • printf("插入4,1,10,3后:"); TranverseList(L); ListDelet(L,5); ListDelet(L,1); ListDelet(L,10); ListDelet(L,8); printf("删除5,1,10,8后:"); TranverseList(L); Insert(L,4); printf("插入4后:...
  • 链表的基础(一) 形式: typedef struct Node{ ElemType data;//ElemType可以是int/char/double等等等 ...单链表插入 s->next = p->next; p->next = s; 单链表删除 q = p->next; p->next = q->next;
  • 单链表插入删除

    2014-03-27 22:55:36
    单链表的实现的插入删除,可以上机执行的!适合初学者!
  • 单链表插入删除节点 public class 链表插入和删除节点 { public static void main(String[] args) { List<Node> list = new LinkedList<>(); for (int i = 0; i < 10; i++) { Node no...
  • 单链表插入

    2012-03-29 22:42:50
    单链表代码 实现链表插入 删除 建立 获取数据
  • 有趣的数据结构算法4——单链表插入元素、删除元素单链表插入元素单链表删除元素实现代码GITHUB下载连接 关于什么是单链表以及如何进行单链表的生成、遍历等操作大家可以关注我的另一篇博文《有趣的数据结构算法3...
  • 单链表插入的很好的学习材料,大家都来看看
  • 单链表插入删除元素

    千次阅读 2019-04-07 10:52:19
    单链表按大小顺序插入删除元素 //按元素大小顺序插入到链表中 #include<stdio.h> #include<stdlib.h> #include<string.h> struct Node { int value; struct Node *next; }; void insert...
  • 实现单链表插入删除,能运行出来,还有完整实验报告
  • int delete(sqlist *L,int i,elemtype *y) ... printf("删除位置不正确!\n"); return 0; } else { *y=(*L).v[i-1]; for(j=i;j<(*L).len;j++) (*L).v[j-1]=(*L).v[j]; (*L).len=(*L).len-1; return 1; } }
  • 小甲鱼 P47 单链表3---单链表插入删除   单链表和数组相比较,最大的优势是插入元素到指定位置的效率。   (单链表插入)让用户输入若干个整数,按顺序插入单链表之中: 比如将3插入2和4之间。对于单链表,...
  • 1、单链表插入删除 题目:单链表插入删除
  • 数据结构单链表插入删除和修改实验报告 一、实验目的 1.理解数据结构中带头结点单链表的定义和逻辑图表示方法。 2.掌握单链表中结点结构的JAVA描述。 3.熟练掌握单链表的插入、删除和查询算法的设计与JAVA实现...
  • 创建单链表,并输出链表,插入/删除结点元素。
  • 一、链表的定义: 链表是一种物理存储结构上非连续存储...三、单链表插入: 1、头插法 2、尾插法 3、任意位置插入 class Node{ public int data; public Node next=null; Node(int data){ this.data=data; ...
  • 6-2 带头结点的有序单链表插入删除 (15 分) 请编写函数实现在带头结点的单链表中进行有序插入和删除操作。 程序运行时,第一行输入元素个数,第二行依次输入各个待插入元素值,第三行输出创建的有序链表中各元素的...
  • 单链表插入的实现

    2019-10-17 11:25:50
    单链表插入的实现 导语:在平时开发的项目中经常会用到LinkedList集合来存储数据,而LinkedList是基于链表结构来存储数据的,包括单向链表和双向链表。本片文章将着重详细介绍一下单链表的基本插入操作 链表:首先...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,097
精华内容 23,238
关键字:

单链表插入删除