精华内容
下载资源
问答
  • 2022-04-05 19:31:47

    算法思想:对链表进行遍历,每次遍历找出整个链表的最小值 输出并释放结点所占的空间,再次查找最小值元素,输出并释放空间,直到链表为空最后释放头结点

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct lnode{
    	int data;
    	struct lnode *next;
    }lnode,*LinkList; 
    int a[10]={4,2,3,1,8};
    int n=5;
    void InitList(LinkList &L){
    	L=(LinkList)malloc(sizeof(lnode));
    	lnode *s,*r=L;
    	for(int i=0;i<n;i++){
    		s=(lnode *)malloc(sizeof(lnode));
    		s->data=a[i];
    		r->next=s;
    		r=s;
    		
    	}
    	r->next=NULL;
    }
    void deleteMin(LinkList &head){
        while(head->next!=NULL){//外层循环判断总共要循环多少次
            lnode *pre=head;//pre为前驱
            lnode *p=pre->next;//p为工作指针
            while(p->next!=NULL){//内层循环来判断最小的元素结点的位置,删掉后后面循环次数减少
                if(p->next->data<pre->next->data){
                pre=p;                          
                }     
    			      p=p->next;  //注意这里不论有没有找到,p都要向后移动     
            } 
            printf("%d",pre->next->data);
            lnode *q=pre->next;
            pre->next=q->next;
            free(q);   
        }
        free(head);
    }
    int main(){
    	LinkList head;
    	InitList(head);
    	deleteMin(head);
    	return 0;
    }

     

    更多相关内容
  • #include<stdio.h> #include<stdlib.h> #include<malloc.h> // 定义存储结构 typedefstruct .../*每元素数据信息*/ structLnode*next; /*后继元素的地址*/ }LNode,*LinkLis...

    #include<stdio.h> 

    #include<stdlib.h> 

    #include <malloc.h> 

    //

    定义存储结构 

    typedef struct 

    Lnode{ 

    int data;  

    /*每个元素数据信息*/ 

    struct Lnode *next; 

    /*后继元素的地址*/ 

    } LNode,*LinkList; 

    void main() 

    void Create_L(LinkList &L,int n); 

    void Print_L(LinkList L); 

    void ReverseList(LinkList L); 

    LinkList La;//

    创建单链表La

     int n; 

    printf("请输入链表La中的元素个数:\n"); 

    scanf("%d",&n); 

    Create_L(La,n);//

    printf("现在La中的元素顺序为:\n"); 

    Print_L(La); 

    printf("-------------------------------------\n\n"); 

    ReverseList(La); 

    printf("逆置后,La的元素顺序为:\n"); 

    Print_L(La);

    void Create_L(LinkList &L,int n) 

    int j=1; 

    L=(LinkList)malloc(sizeof(Lnode)); 

    L->next =NULL;//先建立一个带头结点的单链线性表L 

    for(int i=n;i>0;--i) 

    LinkList p=(LinkList)malloc(sizeof(Lnode)); 

    printf("请输入链表中的第%d个元素:\n",j++); 

    scanf("%d",&p->data); 

    p->next=L->next; 

    L->next =p; 

    }//(逆序实现) 

    /* LinkList q=L; 

     for(int i=1;i<=n;i++)  

    LinkList p=(LinkList)malloc (sizeof(Lnode)); 

    q->next=p; 

    p->next=NULL; 

    q=q->next  

    printf("请输入链表La中的第%d个元素:\n",i); 

     

    scanf("%d",&p->data); 

    }//(正序实现) 

    */ 

    }//

    初始化单链表

    //

    输出单链表

    void Print_L(LinkList L) 

    LinkList p; 

    p=L->next; 

    while(p) 

    printf("%d ",p->data ); 

    p=p->next; 

    printf("\n"); 

    }

    void ReverseList(LinkList L) 

    LinkList p,q; 

    p=L->next; 

    L->next=NULL; 

    while(p!=NULL) 

    q=p->next;

     /*q指针保留p->next得值*/ 

    p->next=L->next; 

    L->next=p; 

    /*将p结点头插入到单链表L中*/ 

    p=q; 

    /*p指向下一个要插入的结点*/ 

    }

    转载于:https://www.cnblogs.com/xufeng123/p/7788463.html

    展开全文
  • 核心代码 void Count(LinkList head,int y) { LinkList p; p=head; int n=0; while(p->next!=NULL) { p=p->next; if(p->data==y) ... printf("%d出现次数:%d",y,n); } main函数...

    核心代码

    void Count(LinkList head,int y)
    {
    	LinkList p;
    	p=head;
    	int n=0;
    	while(p->next!=NULL)
    	{
    		p=p->next;
    		if(p->data==y)
    			n++;			//while循环统计出现次数
    	}
    	printf("%d出现次数为:%d",y,n);
    }
    

    main函数部分

    int main()
    {
    	LinkList Tail_Head;
    	int m;
    	ElemType d[6]={17,24,5,45,6,17};
    	Tail_Head=CreateListTail(d,6);
    	printf("单链表是:\n");
    	PrintList_List(Tail_Head);
    	printf("\n");
    	printf("请输入需要统计的值:");
    	scanf("%d",&m);
    	Count(Tail_Head,m);
    	printf("\n");
    	return 0;
    }
    

    全部代码

    #include <stdio.h>
    #include<stdlib.h>
    #include<iostream>
    #include<string>
    typedef int Status;
    typedef int ElemType;
    typedef struct Node{
       ElemType data;  //存放元素值
       struct Node *next;//指针域指向后继结点
    }Node;
    typedef struct Node * LinkList;
    LinkList InitList_List(void);		//初始化
    LinkList CreateListTail(ElemType a[],int n);		//建表
    void PrintList_List(LinkList head);			//输出
    void Count(LinkList head,int y);		//统计
    int main()
    {
    	LinkList Tail_Head;
    	int m;
    	ElemType d[6]={17,24,5,45,6,17};
    	Tail_Head=CreateListTail(d,6);
    	printf("单链表是:\n");
    	PrintList_List(Tail_Head);
    	printf("\n");
    	printf("请输入需要统计的值:");
    	scanf("%d",&m);
    	Count(Tail_Head,m);
    	printf("\n");
    	return 0;
    }
    LinkList InitList_List(void)
    {
    	LinkList head;
    	head=(Node *)malloc(sizeof(Node));
    	if(head ==NULL) exit(1);
    	head->next=NULL;
    	return head;
    }
    LinkList CreateListTail(ElemType a[],int n)
    
    {
    	LinkList head,p,q;
    	int i;
    	head=InitList_List();
    	q=head;
    	for(i=0;i<n;i++)
    	{
    		p=(Node *)malloc(sizeof(Node));
    		p->data=a[i];
    		q->next=p;
    		q=p;
    	}
    	p->next=NULL;
    	return head;
    }
    void PrintList_List(LinkList head)
    {
    	LinkList p;
    	p=head;
    	while(p->next!=NULL)
    	{
    		p=p->next;
    		printf(" %d  ",p->data);
    	}
    }
    void Count(LinkList head,int y)
    {
    	LinkList p;
    	p=head;
    	int n=0;
    	while(p->next!=NULL)
    	{
    		p=p->next;
    		if(p->data==y)
    			n++;			//while循环统计出现次数
    	}
    	printf("%d出现次数为:%d",y,n);
    }
    

    结果
    在这里插入图片描述
    看完点赞!!!谢谢!!!

    展开全文
  • (2.0分)【单选题】某线性表中最常用的操作是最后一个元素之后插入一个元素和删除第一个元素,则采用()存储方式最节省运算时间。 (4.0分)【简答题】善于分析的【简答题】音乐家【单选题】非空的循环单链表head的尾...

    【判断题】链表中的头结点仅起到标识的作用。 (2.0分)

    【单选题】某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素,则采用()存储方式最节省运算时间。 (4.0分)

    【简答题】善于分析的

    【简答题】音乐家

    【单选题】非空的循环单链表head的尾结点p满足()。 (4.0分)

    【简答题】有组织能力的

    【单选题】若某线性表最常用的操作是存取任 一 指定序号的元素和在最后进行插入和删除运算,则利用()存储方式最节省时间。 (4.0分)

    【填空题】设单链表的结点结构为(data,next),next为指针域,已知指针px指向单链表中data为x的结点,指针py指向data为y的新结点 , 若将结点y插入结点x之后,则需要执行以下语句:_______; ______; (4.0分)

    【单选题】下面的叙述正确的是() (4.0分)

    【单选题】下面关于线性表的叙述中,错误的是哪一个?() (4.0分)

    【简答题】摄影师

    【其它】《JAVA程序设计》实验报告24.doc

    【简答题】

    【单选题】双向链表中有两个指针域,llink和rlink分别指向前趋及后继,设p指向链表中的一个结点,现要求 删去p所指结点,则正确的删除是()。 (4.0分)

    【填空题】循环单链表的最大优点是:________。 (2.0分)

    【简答题】《JAVA程序设计》实验报告25.doc

    【简答题】空乘人员

    【简答题】执行下列程序,说出下列程序的输出结果,了解静态内部类。 class RedCowForm { static class RedCow { //静态内部类是外嵌类中的一种静态数据类型 void speak() { System.out.println("我是红牛"); } } } class BlackCowForm { public static void main(String args[]) { RedCowForm.RedCow red = new RedCowForm.RedCow(); //如果RedCom不是静态内部类,此代码非法 red.speak(); } }

    【判断题】为了很方便的插入和删除数据,可以使用双向链表存放数据。( ) (2.0分)

    【判断题】循环链表不是线性表。 (2.0分)

    【简答题】记者

    【简答题】消防员

    【简答题】请说出下列程序的输出结果。 import java.io.IOException; public class E { public static void main(String args[]){ try { methodA(); } catch(IOException e){ System.out.print("你好"); return; } finally { System.out.println(" fine thanks"); } } public static void methodA() throws IOException{ throw new IOException(); } }

    【判断题】链表是采用链式存储结构的线性表,进行插入、删除操作时,在链表中比在顺序存储结构中效率高。 ( ) (2.0分)

    【判断题】线性表的特点是每个元素都有一个前驱和一个后继。 (2.0分)

    【简答题】人际关系的

    【单选题】在单链表指针为p的结点之后插入指针为s的结点,正确的操作是:( )。 (4.0分)

    【填空题】顺序存储结构是通过________表示元素之间的关系的;链式存储结构是通过________表示元素之间的关系的。 (4.0分)

    【单选题】下述哪一条是顺序存储结构的优点?( ) (4.0分)

    【填空题】带头结点的双循环链表L中只有一个元素结点的条件是:________ (2.0分)

    【判断题】内部类的外嵌类的成员变量在内部类中仍然有效

    【判断题】线性表采用链表存储时,结点和结点内部的存储空间可以是不连续的。 (2.0分)

    【填空题】线性结构包括______、______、_______和_______。线性表的存储结构分成______和______。 (12.0分)

    【判断题】内部类中的方法也可以调用外嵌类中的方法

    【简答题】《JAVA程序设计》实验报告26.doc

    【单选题】对于一个头指针为head的带头结点的单链表,判定该表为空表的条件是()。 (4.0分)

    【填空题】在单链表L中,指针p所指结点有后继结点的条件是:_ _ (2.0分)

    【填空题】当线性表的元素总数基本稳定,且很少进行插入和删除操作,但要求以最快的速度存取线性表中的元素时,应采用_______存储结构。 (2.0分)

    【简答题】店员

    【简答题】有冒险精神的

    【简答题】电脑程序员

    【简答题】飞行员

    【简答题】接线员

    【填空题】下面是用c语言编写的对不带头结点的单链表进行就地逆置的算法,该算法用L返回逆置后的链表的头指针,试在空缺处填入适当的语句。 void reverse (LinkList *L) {LinkList p,q; q=(*L); p=NULL ; while (q!=NULL) { (1) ; q->next=p ; p=q; (2)___ ; } ( 3)_____; } 注:结点类型定义为: typedef struct Lnode { int data; struct Lnode *next; }Lnode,*LinkList; (12.0分)

    【简答题】出租车司机

    【判断题】内部类的类体中可以声明类变量和类方法

    【简答题】护士

    【单选题】下列代码标注的(A,B,C,D)中哪一个是错误的? class OutClass { int m = 1; static float x; //A class InnerClass { int m =12; //B static float n =20.89f; //C InnerClass(){ } void f() { m = 100; } } void cry() { InnerClass tom = new InnerClass(); //D } }

    【简答题】敏感的

    【判断题】对任何数据结构链式存储结构一定优于顺序存储结构。 (2.0分)

    展开全文
  • 假设带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针),试编写相应的置空队、判空对、入队和出队等算法。 步骤: 1.算法分析: 要写出置空队、判空队、入队和出队的算法之前...
  • 结点,第一个结点,头指针

    千次阅读 2019-01-21 15:19:35
    头指针:指链表的指针,是指向链表中第一个节点(或为头结点或为首元结点)的指针结点:是链表开始结点之前附加的一个结点,其数据域一般无意义,不存放有效数据。 △带头结点与不带头结点的区别带头结点...
  • 篇文章弄懂数据结构中的结点与头指针

    千次阅读 多人点赞 2020-02-07 04:47:57
    学习数据结构链表部分时我们和结点以及头指针可谓冤家路窄。很多时候对这两个概念的混淆会使我们构造链表或者做数据结构题目时非常难受。这里我对这两个概念做了小小的总结。 首先我们定义一个链表结点的结构体...
  • 数据结构:头指针结点详解(新手.小白)

    千次阅读 多人点赞 2019-10-26 22:18:22
    1.结点:(1)数据结构中,单链表的开始结点之前设立一个节点称之为头结点,结点的数据域可以不存储任何信息,也可以存储链表的长度等附加信息,结点的指针域存储指向第一个结点的指针(即第一个结点的存储...
  • 单链表头节点,头指针

    万次阅读 多人点赞 2018-06-12 21:17:55
    ...链表中第一个结点的存储位置叫做头指针,那么整个链表的存取就必须是从头指针开始进行了。之后的每一个结点,其实就是上一个的后继指针指向的位置。 这里有个地方要注意,就是对头指针...
  • 9,给定一个带表头结点的单链表,设head为头指针,结点结构(data, next), data整型元素, next为指针,试写出算法:按递增次序输出单链表中各结点的数据元素,并释放结点所占的存储空间(要求:不允许使用数组作为辅助...
  • void sortDel(LinkList* L){ LinkList *p,*pre,*minp,*minpre; LinkList* temp; while(L->next!=NULL){ p = L->next; pre = L; minpre = pre; minp = p; while(p!=NULL){ if(p->data < mi
  • /*设计一个递归算法,删除带头结点的单链表L中所有值x的结点*/ #include <stdio.h> #include <stdlib.h> typedef struct Link{ int data;//代表数据域 struct Link* next;// 代表指针域,指向直接...
  • 不改变链表的前提下,请设计一个尽可能高效的算法,查找链表中倒数第k个位置上的结点(k正整数),若查找成功,算法输出该结点的data域的值,并返回1;否则,只返回0,要求: 1)描述算法的基本设计思想。 2)描述算法的详细...
  • 单链表中,我们有了结点时,我们可以用O(1)的时间访问第一个结点,但对于要访问最后一个结点,我们必须要挨个向下索引,所以需要O(n)的时间。 用O(1)的时间就可以由链表指针访问到最后一个结点。 不过我们需要...
  • 很多正在学C语言的小伙伴可能很快就会学到结构体了,当然单链表可是结构体里面的一块硬骨头,单链表中我们要能够创建,删除,添加...1.点是为了操作方便而设立的,放在第一个元素结点之前,其数据一般无意义(但也...
  • 结点和头指针的理解

    千次阅读 2019-02-14 21:28:55
    线性表使用顺序(数组)存储时有个弊端,那就是插入和删除时需要大量的移动数据,这显示是非常消耗时间的,所以可以采用链式存储,即有一个指针域(单链表),来记录下个结点的存储位置(地址),这样插入和删除...
  • 头指针指向的是链表的第一个结点,其指针域储存的是第一个结点内存中的位置。 结点是单链表的第一个结点,若单链表有结点,则头指针指向结点,若单链表没有结点,则头指针指向第一个结点。 一个单链表可以...
  • { /* 操作结果:构造一个空的线性表L */ *L=(LinkList)malloc(sizeof(struct LNode)); /* 产生结点,并使L指向此结点 */ if(!*L) /* 存储分配失败 */ exit(OVERFLOW); (*L)->next=NULL; /* 指针空 */ ...
  • 头指针head

    千次阅读 2019-06-05 11:54:09
    使用头指针head时,通常先定义head=NULL,目的是初始化时使head有一个明确定义,head不指针。 例: int * head=NUll,* L; L=(LNode * )malloc(sizeof(Lnode)); head=L; 二、head->next=null 把Head...
  • 如果光一个指针p中间你怎么删? 所以,这里我们要定义两个指针一个前驱指针pre,一个指针p 思路: 1.定义两个指针变量pre,p 其中 pre = L, p = pre->next; 2.当p不空时,p->data不等于x时。 pr
  • 链表中使用结点与尾指针

    万次阅读 多人点赞 2018-01-06 21:21:59
    链表头:数据内容一个元素的结点。 头指针:指向结点元素的指针结点:数据内容无效,其指针头指针。 一句话描述头指针是指向结点的指针结点是指向链表头的结点。
  • 已知L为不带表头结点的单链表的表头指针L非空),链表中存储的都是整型数据,写出实现下列运算的递归算法。 (1)求链表中的最大整数 (2)求链表中的结点数 (3)求所有整数的平均值 分析 使用递归的方法...
  • 头指针结点

    千次阅读 2016-12-11 23:42:53
    在一个没有结点的链表里面,我们要插入一个结点我们要传的是头指针的地址,因为我们插入第一个结点的时候要改变头指针 (想改表一个东西就要传它的地址,我们现在要改变的是这个指针 所以要传的是这个指针的地址...
  • 假设带头结点的循环链表表示队列,并且只设一个指针指向队尾结点,但不设头指针,写出相应的入队列和出队列的算法。 分析 本题是链队基本操作的扩展,知道尾指针后,要实现元素入队,则直接用链表的插入操作即可...
  • 已知一个带有表头的单链表,结点结构data-link,假设该链表只给出了头指针list。不改变链表的前提下,请设计一个尽可能高效的算法,查找链表中倒数第k个位置上的结点(k正整数)。若查找成功,算法输出该结点...
  • 关于链表中头指针结点的理解

    万次阅读 多人点赞 2018-05-29 16:04:03
    线性表使用顺序(数组)存储时有个弊端,那就是插入和删除时需要大量的移动数据,这显示是非常消耗时间的,所以可以采用链式存储,即有一个指针域(单链表),来记录下个结点的存储位置(地址),这样插入和删除...
  • 对循环链表,有时不给出头指针,而给出尾指针可以更方便的找到第一个和最后一个结点。 如何查找开始结点和终端结点? 开始结点:rear->next->next 终端结点:rear 循环链表的合并: void Combine...
  • 试写算法将这两链表连接一起,假设指针hc指向连接后的链表的结点,并要求算法尽可能短的时间完成连接运算。请分析你的算法的时间复杂度。 时间复杂度:O(min(m,n)) LinkList* connect(LinkList *ha,...
  • 原题:有一个有序单链表(从小到大有序),表头指针为 L ,编写一个函数向该单链表中插入一个元素 a 的结点,使插入后链表仍然有序。 说明:以下程序先自动生成一个从小到大有序链表,然后要求输入插入结点的数据,...
  • 一、链式存储 用一组地址任意的存储单元(地址可以连续也可以不连续),依次存储线性表中的各数据元素。...由于链表中每个链结点中仅包含一个指针域,故称这样的链表线性链表或单链表。 单链表的结点结构

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 397,228
精华内容 158,891
关键字:

在一个以l为头指针