精华内容
下载资源
问答
  • 无头结点单链表(带注释)代码实现
    2022-03-17 11:36:02
    #include<stdio.h>
    #include<stdlib.h>
    
    /*创建单链表步骤:
    *1.单链表有指针域和值域,先创值域和指针域
    *2.定义一个结构体类型和结构体的指针类型
    *3.有了指针创建链表
    *4.链表没有节点再创建节点
    *5.插入节点
    *6.释放空间
    */
    //结构体创建值域和结构体指针域
    
    struct node
    {
    	int num;
    	char name[20];
    	char sex[10];
    	int age;
    
    	struct node *next;  //注意这里的结构体指针必须是自己结构体的
    };
    
    typedef struct node Node; //结构体名
    typedef Node * Link; //结构体类型的指针
    
    //创建链表
    void create_link(Link *head)
    {
    	//取第一个节点的内容,其实就是一个地址,但是现在没有节点,所以要将内容为空
    	*head = NULL;
    }
    
    //创建新的节点
    void create_node(Link *new_node)
    {
    	*new_node = (Link)malloc(sizeof(Node)); //给结构体分配空间
    }
    
    //插入链表
    void insert_node_head(Link *head,Link new_node)
    {
    	new_node->next = *head;
    	*head = new_node;
    }
    
    //列出链表
    void display_link(Link head)
    {
    	Link p = NULL;
    	p = head;
    
    	while(p != NULL)
    	{
    		printf("%d\n",p->num);
    
    		p = p->next;
    	}
    }
    
    //释放空间
    void release_link(Link *head)
    {
    	Link p = NULL;
    	p = *head;
    
    	while(*head != NULL)
    	{
    		*head = (*head)->next;
    		free(p);
    		p = *head;
    	}
    
    	if(*head == NULL)
    	{
    		printf("link is empty");
    	}
    
    	printf("\n");
    }
    
    int mian()
    {
    	//定义结构体指针变量
    	Link head = NULL; //定义结构体指针类型的头指针
    	Link new_node = NULL;
    	int i;
    
    	//创建链表
    	create_link(&head); //将头指针的地址传入
    
    	for(i = 0;i < 10;i++)
    	{
    		//创建节点
    		create_node(&new_node);
    		new_node -> num = i + 1;
    
    		//插入链表
    		insert_node_head(&head, new_node);
    	}
    	
    	//展现链表
    	display_link(head);
    
    	//释放链表空间
    	release_link(&head);
    
    	return 0;
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    更多相关内容
  • 头插法创建无头结点单链表

    头插法创建无头结点单链表

    #include <iostream>
    using namespace std;
     
     
    /*
    *writer:yaojinhui
    */
    #define Eletype char
    typedef struct LNode
    {
    	Eletype data;
    	struct LNode *next;
    }LNode,*Linklist;
    void createList(Linklist &L)
    {
    	LNode *q;
    	L=NULL;
    
    	char ch;
    	while(1)
    	{
    		cin>>ch;
    		if(ch=='#')
    			break;
    		q=new LNode;
    		q->data=ch;
    
    		q->next=L;
    		L=q;
    	}
    }
    void print(Linklist L)
    {
    	LNode *p;
    	p=L;
    	while(p)
    	{
    		cout<<p->data;
    		p=p->next;
    	}
    	cout<<endl;
    }
    int main() {
    	Linklist L;
    	createList(L);
    	print(L);
    	return 0;
    }
    
    

    在这里插入图片描述

    展开全文
  • 无头结点单链表的插入删除语句

    千次阅读 2020-04-29 11:31:05
    已知L是无表头结点单链表,且P结点既不是首元结点,也不是尾元结点。回答下题 1、在P结点后插入S结点的语句序列是 s->next = p->next;//1 p->next = s;//2 如下图所示 2、在P结点前插入S结点的语句序列...

    已知L是无表头结点的单链表,且P结点既不是首元结点,也不是尾元结点。回答下题
    1、在P结点后插入S结点的语句序列是

    s->next = p->next;//1
    p->next = s;//2
    

    如下图所示
    在这里插入图片描述
    2、在P结点前插入S结点的语句序列是
    (1)循序交换数据的情况

    • 先在P结点之后插入S结点
    • 定义一个中间变量将S和P的数据交换
    s->next = p->next;
    p->next = s;
    ElemType tmp = s->data;
    s->data = p->data;
    p->data = tmp;
    

    (2)不允许交换数据
    单链表不能回退,不能获取到P之前的结点,但是我们又得找到P结点之前的结点

    Q = P;
    P = L;
    while(P->next != Q)
    {
    	P = P->next;
    }
    	s->next = Q;//s->next = p->next
    	P->next = s;
    

    如下图所示:
    在这里插入图片描述
    3、在表首插入S结点的语句序列是
    (1)链表中有数据时

    s->next = L;
    L = s;
    

    如下图所示:
    在这里插入图片描述
    (2)链表中无数据时
    通过分析,我们发现上面的代码也能处理我们边界的问题。所以链表中无数据时代码依然是

    s->next = L;
    L = s;
    

    如下图所示:
    在这里插入图片描述
    4、在表尾插入S结点的语句序列是
    (1)链表中有数据

    P = L;
    while(P->next != NULL)
    {
    	P = P->next;
    }
    s->next = P->next;
    P->next = s;
    

    如下图所示:
    在这里插入图片描述
    (2)链表中无元素时

    s->next = L;
    L = s;
    

    如下图所示:
    在这里插入图片描述

    展开全文
  • 因为是无头结点单链表L,L指向第一个结点,所以在插入元素时要考虑插入位置是否在表头,如果是,则要将新结点的next指针指向第一个结点,同时将L重新指向新结点。 重点在于❗❗【指针作为参数时,如何改变它所指向...

    因为是无头结点单链表L,L指向第一个结点,所以在插入元素时要考虑插入位置是否在表头,如果是,则要将新结点的next指针指向第一个结点,同时将L重新指向新结点。

    重点在于❗❗【指针作为参数时,如何改变它所指向的值】❗❗

    在C语言中, 一般而言,在子函数内,要想改变传进来的参数(全局变量)的值,必须要用到指针。

    • 比如 int a = 0,子函数应该这样写:xxxx(int *a),表示传进来的参数类型为指针类型,并且在子函数内部,单一个 (a) 表示的是 (原a)的地址,(*a)才是原来的(a),❗(*a)才等于0,要想改变(原a) 的值,对 (*a)❗重新赋值即可。(注意区分:①&为取址运算符,②为指针类型标识符。)

    • 对于指针同理,这里以指向链表第一个结点的指针L为例。当新元素插入位置位于链表开头时,需要将指针L重新指向新结点,即需要改变L所指向的值。L原本就是一个指针,对指针取值,子函数参数里要写成 **L,这里L是LinkList类型的指针变量,所以在参数里写成(*L)即可。同理,在函数内部,在未改变L所指向的值时,(*L)的值才是第一个结点的地址,想改变L所指向的值,对❗(*L)重新赋值即可。

    #include<stdio.h>
    #include<malloc.h>
    #include <stdlib.h>
    #define error -1;
    #define OK 1;
    
    typedef int ElemType;
    typedef int status;
    
    typedef struct LNode
    {
        ElemType data;
        struct LNode *next;
    }LNode, *LinkList;
    
    
    LinkList creat()
    {//使用尾插法建表;
        LinkList L;
    //    L = (LinkList)malloc(sizeof(LNode));
    //    if(!L)   printf("memory malloc error!\n");
    //    LinkList p = L;
        ElemType a;
        int len;
        
        printf("请输入待建表的表长:");
        scanf("%d", &len);
        if(len>1)
        {
            printf("请输入第1个元素的值:");
            scanf("%d", &a);
            L = (LinkList)malloc(sizeof(LNode));
            if(!L)   
                printf("memory malloc error!\n");
            L->data = a;
            LinkList p = L;
            
            for(int i=1; i<len; i++)
            {   
                printf("请输入第%d个元素的值:", i+1);
                scanf("%d", &a);
                p->next = (LinkList)malloc(sizeof(LNode));
                p->next->data = a;
                p = p->next;
        }
        
        p->next = NULL;
        
        return L;
        }
        
    }
    
    void print(LinkList L)
    {
        LinkList p = L;
        while(p != NULL)
        {
            printf("%d\n", p->data);
            p = p->next;
        }
    }
    
    status insert(LinkList *L, int i, int b)    
    {//这里形参取的是指向指针L的指针,即L的地址,*在这里表示指针类型
    //因为有可能要改变指针L的值,即改变L的指向
        LinkList p = NULL;
        if (i<1)     return error;
        
        if (i == 1)
        { 
            p = (LinkList)malloc(sizeof(LNode));
            if(!p)   
                printf("memory malloc error!\n");
            p->data = b;
            p->next = *L;   //注意这里!!!*L才是原L,*的意思是【取】指针所指向的值
                            //此时L是原L的地址,想要取/改变原L的值,用*L
            *L = p;         //改变原L的指向,就用*L
            
            return OK;
        }
        else
        {
            p = (LinkList)malloc(sizeof(LNode));
            if(!p)   
                printf("memory malloc error!\n");
            p->data = b;
            
            LinkList q = *L;     //q用于查找插入位置
            LinkList qpre = NULL;   //qpre用于指向待插入位置的前一结点
            
            while(i>1)
            {
                qpre = q;
                q = q->next;
                i --;
            }//退出时,q指向待插入位置
            
            p->next = q;
            qpre->next = p;
            
            return OK;
        }
    }
    
    
    
    int main()
    {
        LinkList L = creat();
        int i;
        printf("请输入待插入的位置:");
        scanf("%d", &i);
        int b;
        printf("请输入待插入的元素值:");
        scanf("%d", &b);
        
        insert(&L, i, b);       
    //!!&取地址符,要将指针L的地址作为参数传进去,因为L所指向的值可能会发生改变
        
        print(L);
        
        return 0;
    }
    
    展开全文
  • } } // 删 //初始化单链表 public void init(){ first = null; last = null; } //删除第i个 ,,判断第i个是否可删除 public void delI(int i){ if(i>size || i){ System.out.println("越界"); return; } //头删 if...
  • c实现无头结点单链表

    2017-06-21 18:29:47
    //销毁单链表 void Display(pList plist);//遍历单链表 void PushBack(pList* pplist, DataType x);//尾插 void PopBack(pList* pplist);//尾删 void PushFront(pList* pplist, DataType x);//头插 void PopFront...
  • 无头结点单链表la,转化成无头结点单链表lb, lb(i)=la(从la(i)到la(n)的累加) 要求时间复杂度为o(n)
  • 无头结点单链表

    2017-10-21 17:30:57
    #include using namespace std; typedef struct LNode { int data;... //LList(实质为LNode*)的无头结点表头 bool isEmptyLList(LList L) { //判断是否空表 if (L) return false; else return t
  • 创建无头结点单链表

    千次阅读 2018-04-01 23:23:45
    //输出无头结点单链表 void List(ListNode *L) { ListNode *p; p = L; // while (p != NULL) { printf ( "%2d" , p->val); p = p->next; } } }; int main() { ListNode *L1; int temp;...
  • 只实现了初始化、头插、尾插、按值删、判空、输出的功能 nolist.h文件 #pragma once typedef struct NNode { int data; struct NNode* next; }NNode,*NList; void InitList(NList* pplist);...bool
  • 我清晰记得,以前在数据结构课上,老师和我们说:涉及到链表的操作,一定要在纸上把过程先画出来,再写程序。 现在想想,这句话简直就是真理! 好理解的双指针 定义两个指针: prepre 和 curcur ;...
  • 无头结点单链表的基本操作
  • 无头结点单链表基本操作

    千次阅读 2018-04-17 11:45:01
    // 在链表中查找值为data的元素,找到后返回值为data的结点 PNode SListFind(PNode pHead, DataType data ); // 在pos位置插入值为data的结点 void SListInsert(PNode * pHead, PNode pos, DataType data )...
  • 1、问题描述 插入排序是把一个记录插入到已排的有序序列中... } 3、输出结果 心得体会 在编写程序的时候,无头结点单链表直接插入排序,这可以作为c语言初学者练手的小程序,当然程序中多多少少有错误,望指正留言!
  • 复习数据结构,本来题目是删除具有x值的结点,但是不先创建链表,哪来的删呢?...创建无头结点单链表(尾插法) LNode *CreatList_Nhead()//无头结点,返回指针类型 { ElemType x; LNode *head; LNode *
  • 不带头结点的单链表。 属于线性表的一种,采用链式存储的存储结构。 优点: 空间动态分配,不要求连续的大片空间。 插入删除方便(时间复杂度低)。 ...相对于带头结点的单链表 插入、删除不统一(实现比较... * 无头结点
  • 数据结构 无头结点单链表

    千次阅读 2019-03-15 17:52:38
    如何建立一个无头结点单链表?不能在头结点的数据域中放数据再变成假的第一个数据节点在进行操作,那是自己骗自己。 在单链表中我们直接头结点进行解引用,但无头结点的链表最初其实就是一个指针,没有指向任何...
  • 创建无头结点单链表

    千次阅读 2021-03-08 23:03:59
    如何创建无头结点单链表 我们常见的创建单链表都是带头节点的,这很方便,但有时候需要使用不带头节点的单链表,如何创建呢? 创建多个节点的单链表,因为刚开始表头是空的,所以需要在循环里加入判断。代码如下:...
  • 无头结点单链表的c算法的实现,里面有验证程序可以参考,在调试中通过。
  • 无头结点单链表一系列操作

    千次阅读 2018-12-21 17:21:15
    无头结点单链表的一系列操作 没有头结点的链表,C++实现其初始化,建立,插入,删除,查询,计算长度,输出。感觉没有头结点好多操作都变得复杂了那么一丢丢。 目录   无头结点单链表的一系列操作 初始化 ...
  • 基于单链表的面试题——进阶篇什么是无头结点链表??? singlelinkedlist.h头文件#ifndef __SINGLELINKEDLIST_H__ #include #include #include typedef int DataType;typedef struct ListNode
  • 无头结点单链表的尾插法建立和删除 题目来自浙大版《C语言程序设计(第3版)》题目集 本题要求实现两个函数,分别将读入的数据存储为单链表、将链表中所有存储了某给定值的结点删除。链表结点定义如下: struct ...
  • 无头结点单链表(C语言)

    千次阅读 2018-09-22 18:59:00
    1.单链表:  在顺序表中,用一组地址连续的存储单元来一次存放线性表的结点,因此结点的逻辑顺序与物理顺序是一致的。但链表却不同,链表是用一组任意的存储单元来存放 线性表的结点,这组存储单元可以是连续的,...
  • 首先对单链表的结构进行介绍,单链表是由很多个节点一个接一个串接起来的,每个节点包含两部分,数据部分和地址部分,我们这里讲的是无头单链表,所以没有头节点,每个节点存储的是本身的数据和下一个节点的地址。...
  • 前两天看看视频学会了这道题的解法,但今天做又给忘了!好痛苦~~~ ...先定义一个头结点,然后将头结点指向首元结点,再比较a1和b1(链表a的第一个元素简称“a1”,链表b也是,下文不做解释),如果b1
  • 定义一个结构体 /** * @brief 链表节点 */ typedef struct LinkedNode{ ... * @brief 初始化一个不带头结点单链表 * * @return LinkedList NULL */ LinkedList initLinkedListNoHead() { // 因为.
  • /*单链表(无头结点)*/#include #include #include using namespace std;struct LNode {int data; // 数据域LNode *next; // 指针域};typedef LNode LNode; // 表示单链表的一个结点typedef LNode *LinkList; // 表示...
  • 顾名思义就是从一开就是有用的结点 文章目录定义结构体创建 定义结构体 typedef struct Node { int element; struct Node *next; }LNode, * LinkNode; 创建 这里是手输入,输入为0的时候就退出来 //传入一个头...
  • //head的指针域指向新建立的结点 } } (3)插入结点到第几个结点的位置 LinkList Insert(LinkList head, int i) { Node* p , * s; s = (Node*)malloc(sizeof(Node)); int a; char b[20]; scanf("%s", p->b); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,785
精华内容 1,114
关键字:

无头结点单链表