精华内容
下载资源
问答
  • 1.一个以递增方式排列的链表,去掉链表冗余值。 思路一:设有两个指针p和q,使p不动,q依次往后循环直到p->data不等于q->data,再将中间冗余数据删除。 思路二:设有两个指针p和q,使p在前,q在后,只要找到...
    1.一个以递增方式排列的链表,去掉链表中的冗余值。
    思路一:设有两个指针p和q,使p不动,q依次往后循环直到p->data不等于q->data,再将中间的冗余数据删除。
    思路二:设有两个指针p和q,使p在前,q在后,只要找到一个冗余就删除一个,依次往后删除。
    输入的链表:1 3 3 3 3 6 6 8 9 10
    删除后的链表:1 3 6 8 9 10
    比较两种思路,思路二的想法相比于思路一要好,所以这里实现思路二的代码。
    2.将一个结点插入到一个有序的链表中。
    思路:首先要判定这个链表是递增排列的链表还是递减排列的链表,然后相对应的查找这个结点需要插入的位置。对于递增链表来说,需要查找到第一个节点值大于等于要插入的结点,然后将需要插入的结点插入到该结点前面;对于递减链表来说,需要查找到第一个小于等于要插入的结点,然后将需要插入的结点插入到该结点前面。需要考虑的特殊情况是插入的结点可能会插入在第一个位置。
    #include <stdio.h>
    #include <malloc.h>
    
    #define NULL	0
    
    typedef struct node {
    	int data;
    	struct node *next;
    }ElemSN;
    
    
    ElemSN * creat_link(int ms); //逆向创建一个链表
    void print_link(ElemSN *head); //输出单向链表
    void delete_rdy(ElemSN *head); //删除冗余的项
    ElemSN * insert_node(ElemSN *head, int x); //插入结点到有序链表
    ElemSN * clear_link(ElemSN *head); //删除链表
    
    int main()
    {
    	ElemSN *head;
    	int ms, x;
    
    	printf("Please input node number:");
    	scanf("%d", &ms);
    	head = creat_link(ms); //创建链表
    	print_link(head);
    	delete_rdy(head);
    	print_link(head);
    	head = insert_node(head, 5);
    	print_link(head);
    	head = clear_link(head); //删除链表
    }
    
    ElemSN * creat_link(int ms)
    {
    	ElemSN *h = NULL, *p;
    	int i, x;
    
    	for(i = 0; i < ms; i++)
    	{
    		printf("Please input data:");
    		scanf("%d", &x);
    		p = (ElemSN *)malloc(sizeof(ElemSN));
    		p->data = x;
    		p->next = h;
    		h = p;
    	}
    
    	return h;
    }
    
    void print_link(ElemSN *head)
    {
    	for(; head; head = head->next)
    	{
    		printf("%d ", head->data);
    	}
    	printf("\n");
    }
    
    void delete_rdy(ElemSN *head)
    {
    	ElemSN *p, *q;
    
    	if(NULL == head)
    		return;
    	p = head;
    	q = p->next;
    	while(q)
    	{
    		if(p->data == q->data)
    		{
    			p->next = q->next;
    			free(q);
    			q = p->next;
    		}
    		else
    		{
    			p = q;
    			q = p->next;
    		}
    	}
    }
    
    ElemSN * insert_node(ElemSN *head, int x)
    {
    	ElemSN *p, *q;
    
    	if(NULL == head || NULL == head->next)
    		return NULL;
    	p = head;
    	q = head; //这里不能赋值为head->next,比较必须从第一个结点开始
    	if(q->data >= q->next->data) //递减链表
    	{
    		for(; q && q->data >= x; p = q, q = q->next){}
    	}
    	else //递增链表
    	{
    		for(; q && q->data <= x; p = q, q = q->next){}
    	}
    
    	if(NULL == q) //插入在链表尾部
    	{
    		q = (ElemSN *)malloc(sizeof(ElemSN));
    		q->data = x;
    		q->next = NULL;
    		p->next = q;
    	}
    	else if(q == head) //插入在表首
    	{
    		q = (ElemSN *)malloc(sizeof(ElemSN));
    		q->data = x;
    		q->next = head;
    		head = q;
    	}
    	else //插入在中间位置
    	{
    		p->next = (ElemSN *)malloc(sizeof(ElemSN));
    		p->next->next = q;
    		p->next->data = x;
    	}
    
    	return head;
    }
    
    ElemSN * clear_link(ElemSN *head)
    {
    	ElemSN *p;
    
    	while(head)
    	{
    		p = head->next;
    		free(head);
    		head = p;
    	}
    
    	return head;
    }
    展开全文
  • 链表结点的插入

    2016-05-01 16:33:51
    ---- 单链表第i个位置插入数据结点的算法思路: -- 1)声明一结点 p 指向链表头结点,初始化 j 从1开始; -- 2)当 j时,就遍历链表,让 p 的指针向后移动,不断指向下一结点,j 累加1; -- 3)若到链表末尾p为空,...

    ---- 单链表第i个位置插入数据结点的算法思路:

    -- 1)声明一结点 p 指向链表头结点,初始化 j 从1开始;

    -- 2)当 j<i 时,就遍历链表,让 p 的指针向后移动,不断指向下一结点,j 累加1;

    -- 3)若到链表末尾p为空,则说明第 i 个元素不存在;

    -- 4)否则查找成功,在系统中生成一个空结点s;

    -- 5)将数据元素e赋值给s->data;

    -- 6)单链表的插入标准语句 s->next=p->next;  p->next=s;

    -- 7)返回成功。

    #include <iostream>
    using namespace std;
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    typedef int Status;
    typedef int Elemtype; 
    typedef struct node
    {
    	Elemtype data;
    	struct node *next;
    } Node,*LinkList;
    //typedef struct node *LinkList;
    //typedef Node *LinkList;
    //L:指向头指针的指针(无头结点)
    Status ListInsert(LinkList *L,int i,Elemtype e)
    {
    	int j = 1;
    	LinkList p,s;
    	p = *L;
    	while(p&&j<i)
    	{
    		p = p->next;
    		j++;
    	}
    	if(!p||j>i)
    	{
    		return ERROR;
    	}
    	s = (LinkList)malloc(sizeof(Node));//生成新结点
    	s->data = e;
    	s->next = p->next;p->next=s;
    	return OK;
    }
    2、已知学生链表结点是按学号(number)按从小到大的顺序排列,插入新的结点到链表使其仍然有序。

    #include <iostream>
    using namespace std;
    #define New(p) { p=(STU*)malloc(sizeof(STU));\
    	             printf("please input number and name:\n");\
    				 scanf("%d %s",&p->num,&p->name);\
    				 p->next=NULL;}
    typedef struct Student
    {
    	int num;//学号
    	char name[20];//姓名
    	struct Student *next;
    }STU;
    //链表结点的创建
    STU * Create()
    {
    	/*p1指向新建结点,p2指向前一结点,head指向头结点*/
    	STU *p1,*p2 = NULL,*head = NULL;
    	New(p1);
    	while(p1->num!=0) //学号不为0则添加到链表
    	{
    		if(head == NULL)
    		{
    			head = p1;
    		}
    		else 
    		{
    			p2->next = p1;
    		}
    		p2 = p1;
    		New(p1);
    	}
    	//free(p1);
    	return head;
    }
    //链表结点的插入
    STU * Insert(STU *head,STU *pnew)
    {
    	STU *p1 = head,*p2;
    	if(head == NULL)
    	{
    		head = pnew;//无元素,插入在链表头
    	}
    	else
    	{
    		while(pnew->num > p1->num&&p1->next!=NULL)
    		{
    			p2 = p1;
    			p1 = p1->next;			
    		}
    		if(pnew->num <= p1->num)
    		{
    			if(head == p1) //插入的元素值最小,插入链表头
    			{
    				pnew->next = p1;
    				head = pnew;
    			}
    			else   //插入链表中间
    			{
    				p2->next = pnew;
    				pnew->next = p1;
    			}
    		}
    		else   //插入链表结尾
    		{
    			p1->next = pnew;
    			pnew->next = NULL;
    		}
    	}
    	return head;
    }
    
    //链表的输出
    void Print(STU *p)
    {
    	printf("学生的信息如下:\n");
    	while(p!=NULL)
    	{
    		printf("%d %s\n",p->num,p->name);
    		p = p->next;
    	}
    }
    int main()
    {
    	STU *head = NULL,*pnew;
    	head = Create();
    	printf("Inser a new element:\n");
    	New(pnew);
    	Insert(head,pnew);
    	Print(head);
    	system("pause");
    	return 0;
    }

    输入输出显示:


    展开全文
  • 《程序设计基础实训指导教程-c语言》 ...(2)用这个结点中的年龄和链表中每个结点的年龄进行比较,找到插入点, (4)再通过链表中的指针进行连接, 寻找目标结点和插入的过程用子函数完成 #include<st
    《程序设计基础实训指导教程-c语言》
    ISBN 978-7-03-032846-5
    p143
    7.1.2 上级实训内容
    

    【实训内容12】建立一个按年龄排序的有序链表,每个结点包括学号、姓名、性别、年龄。建立一个新的结点,通过年龄将此结点插入到链表中去,使之仍然有序

    分析:
    (1)建立一个有序链表,再建立一个和链表中结点一样的结点,
    (2)用这个结点中的年龄和链表中每个结点的年龄进行比较,找到插入点,
    (4)再通过链表中的指针进行连接,
    
    寻找目标结点和插入的过程用子函数完成
    
    #include<stdio.h> 
    #include<stdlib.h> 
    struct Node 
    { 
        int value; 
        struct Node *next; 
    }; 
    void insertNode(struct Node **head,int value)   //**head为头指针的地址,value为插入结点的信息
    { 
        struct Node *previous;  //指向插入点前一个结点
        struct Node *current;   //指向当前结点
        struct Node *new;       //指向插入结点
    
        //current记录链尾位置
        current =*head; //当前指针赋给头指针的地址
        previous=NULL;  //指向前一个结点的指针赋为空
    
        while(current!=NULL && current->value < value)   //当前指针指向的结点不为空 && 当前指针指向的结点信息 < 要插入的值
        { 
            previous=current;   //指向前一个结点的指针后移
            current=current->next;  //指向当前结点的指针后移
        } 
    
        new=(struct Node *)malloc(sizeof(struct Node)); //给新结点申请内存空间
    
        if(new==NULL) 
        { 
            printf("内存分配失败\n"); 
            exit(1); 
        } 
        new->value=value;   //插入的值赋给新结点的结点结点信息
        new->next=current;  //新结点与当前结点链接
     
        if(previous==NULL)  //若当前结点为空(空链表)
        { 
            *head=new;  //让头指针指向新结点
        } 
        else 
        { 
            previous->next=new; //当前结点的next指针指向新结点
        } 
    } 
    void printNode(struct Node *head)
    {
        struct Node *current;   //让头指针给current指针,遍历输出链表
        current=head; 
        while(current!=NULL) 
        { 
            printf("%d ",current->value);
            current=current->next;
        }
    }
    int main()
    { 
        struct Node *head=NULL;
        int input;
        while(1) 
        {
            printf("\n输入一个整数(-1结束):"); 
            scanf("%d",&input); 
            if(input==-1) 
            {
                break; 
            }
            insertNode(&head,input); 
            printNode(head); 
        }
    }
    

    在这里插入图片描述

    展开全文
  • 编写一个函数dellink,用来删除动态链表中一个指定的结点(由实参指定某一学号,表示要删除该学生结点)。 编写一个函数insertlink,用来向动态链表插入一个结点。 编写一个函数freelink,用来释放一个动态链表。 In

    Description

    编写一个函数creatlink,用来建立一个动态链表。(包含学号和成绩)
    编写一个函数printlink,用来输出一个链表。
    编写一个函数dellink,用来删除动态链表中一个指定的结点(由实参指定某一学号,表示要删除该学生结点)。
    编写一个函数insertlink,用来向动态链表插入一个结点。
    编写一个函数freelink,用来释放一个动态链表。

    Input

    输入多个学生的学号和成绩,建立动态链表,以0 0 结束
    输入学号,删除链表中的对应结点
    插入两个链表结点

    Output

    输出的链表

    #include<iostream> 
    #include<iomanip> 
    using namespace std;
    /********************************************************/
    struct student 
    { 
        long num; 
        float score; 
        student *next; 
    };
    /********************************************************/ 
    student *creatlink(void)//建立链表 
    { 
        student *st=new student,*pend,*head;//申请内存空间 
        cin>>st->num>>st->score;//输入学生信息 
        head=NULL;
        while(st->num!=0)//当输入0 0时结束
        { 
            if(head==NULL) 
                head=st;//head起个头 
            else
                pend->next=st;//指向下一个结点的地址
            pend=st;
            st=new student;//重新申请内存地址
            cin>>st->num>>st->score; 
        } 
        pend->next=NULL; 
        delete st;//把多申请的那个释放 
        return head;//返回首地址,千万别改
    }
    /********************************************************/ 
    void printlink(student *head)//链表输出 
    { 
        while(head!=NULL) 
        { 
            cout<<head->num<<" "<<head->score<<endl; 
            head=head->next; 
        } 
    }
    /********************************************************/ 
    student *dellink(student *head,long del)//删除 
    { 
        student *p1,*p2=head; 
        while(p2!=NULL)
        {    
              
            if(del==p2->num) 
            { 
                p1->next=p2->next;
    			//上一个的next指向被删除结点的下一个地址
    			//也就是上一个的next的值换成下一个next的值
                break; 
            } 
            else
            { 
                p1=p2; 
                p2=p2->next; 
            } 
        } 
        return head; 
    }
    /********************************************************/ 
    student *insertlink(student *head,student *std)//插入 
    { 
        student *p2=head,*p1,*st=new student;//一定要申请新的内存地址 
        st->num=std->num;//把值赋给st就可以了,别赋地址
        st->score=std->score; 
        st->next=std->next; 
        while(p2->next!=NULL) 
        { 
            if(p2->num<st->num&&st->num<p2->next->num)
    		//简单的排一下序
            { 
                p1=p2->next; 
                p2->next=st; 
                st->next=p1; 
                return head;
    			//插进去了就退出吧
            } 
            else
                p2=p2->next; 
        } 
        if(p2->next==NULL)//当在最后插入结点时        
        { 
            p2->next=st; 
            st->next=NULL;//别忘了
        } 
        return head; 
    }
    /********************************************************/ 
    void freelink(student *head)//释放链表
    { 
        student *p1=head,*p2; 
        while(p1!=NULL)//排着释放
        { 
            p2=p1->next; 
            delete p1; 
            p1=p2; 
        } 
    }
    /********************************************************/ 
    int main() 
    { 
        student *creatlink(void); 
        student *dellink(student *,long); 
        student *insertlink(student *,student *); 
        void printlink(student *); 
        void freelink(student *); 
        student *head,stu; 
        long del_num; 
        head=creatlink(); 
        cin>>del_num; 
        head=dellink(head,del_num); 
        cin>>stu.num>>stu.score; 
        head=insertlink(head,&stu); 
        cin>>stu.num>>stu.score; 
        head=insertlink(head,&stu); 
        cout<<setiosflags(ios::fixed); 
        cout<<setprecision(2); 
        printlink(head); 
        freelink(head); 
        return 0; 
    }
    /*
    Sample Input
    1001 100
    1002 95
    1005 90
    1008 76
    0 0
    1005
    1006 98
    1009 99
    Sample Output
    1001 100.00
    1002 95.00
    1006 98.00
    1008 76.00
    1009 99.00
    */
    
    
     
    

    展开全文
  • /*创建一个带头结点的链表,头部插入法创建*/ #include<stdio.h> #include<stdlib.h> #define DataType char typedef struct node { DataType data; struct node *next; }ListNode,*...
  • 无头结点的链表顺序插入 按照大小顺序插入时需要记录插入位置前面一个节点的指针,因此使用两个指针对链表进行遍历,另外,用函数对无头链表进行插入等操作,要用一个指针来进行而且输入要使用指针的地址,否则返回...
  • 1.一个以递增方式排列的链表,去掉链表冗余值。 思路一:设有两个指针p和q。使p不动,q依次往后循环直到p->data不等于q->data,再将中间冗余数据删除。 思路二:设有两个指针p和q,使p在前,q在后,...
  • 双向链表结点的插入和删除算法

    千次阅读 多人点赞 2018-10-03 23:47:46
    双向链表的插入与删除 双向链表结点定义 #define ElemType int //双向链表的存储结构 typedef struct DuLNode { ElemType data; DuLNode *prior; DuLNode *next; }DuLNode, *DuLinkList; 双向链表...
  • 链表的结点插入

    2020-03-15 17:59:11
    师–链表的结点插入 Description 给出一个只有头指针的链表和 n 次操作,每次操作为在链表的第 m 个元素后面插入一个新元素x。若m 大于链表的元素总数则将x放在链表的最后。 Input 多组输入。每组数据首先输入一个...
  • 链表——结点的插入

    2016-10-30 19:24:43
    下面代码包括了头插,尾插两种插入方式。#include #include <stdlib.h>struct node { int num; struct node * next; };typedef struct node Node; typedef Node * Link;void create_link(Link * head)//创建一...
  • 师--链表的结点插入 Time Limit:1000 msMemory Limit:65536 KiB SubmitStatistic Problem Description 给出一个只有头指针的链表和 n 次操作,每次操作为在链表的第 m 个元素后面插入一个新元素x。若m 大于链表...
  • 下列给定程序中已建立一个带头结点的单向链表,链表中各节点按节点数据域中的数据递增有序链接。函数fun的功能是:把形参x的值放入一个新节点并插入列表中使插入后各节点数据域中的数据仍保持递增有序。  请在程序的...
  • 1、在无头单链表一个非头结点插入一个结点2、逆置链表单链表结构以及Find函数参见 2016-1-2 13:56 发表博客voidInsertFront(SListNode*pos,constDataTypex)//在无头单链表一个非头结点插入一个结点{//初步...
  • 带头结点的单向链表 带有表头结点,头结点有前驱,所有结点都有前驱 插入与删除不需要分头、 中间、 尾 查找链表结点时不需要两指针联动 typedef struct node{ int data; //数据域 struct node*next; //指针域...
  • 带头结点的双向链表简单理解增删图解头文件代码文件测试用例参考资料 简单理解 我们会发现,单链表由于只有next域,所以,如果想要访问某个元素的前驱结点,那么只能从头开始遍历到该元素的前一个元素。效率非常的...
  • 链表链表的结点插入

    千次阅读 2018-03-17 13:00:42
    师–链表的结点插入 Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Problem Description 给出一个只有头指针的链表和 n 次操作,每次操作为在链表的第 m 个元素后面插入一个新元素x。若m ...
  • 常见面试编程题 ... 第一遍:在原链表中的每个结点后插入一个与原结点值相同的新结点,新结点的rand指针设为NULL。 第二遍:将每个新结点的rand指针指向它的原结点(前驱结点)的rand指向的随机结点的下一...
  • 链表: 1、什么是链表 2、链表的三要素: 头指针(head):头指针是用来说明链表的开始了,头指针就代表了链表...结点(node):链表当中每一个变量被称为结点 尾指针:用来说明链表结束(它是一个空指针,NULL) ...
  • 参照这位大神内容,我把昨天双向链表做了改进,变成了有独立表头双向链表
  • 这是我面试经历以及整理相关面试高频题目,希望...先查看原始链表结构,准备将结点x插入链表中。此时我们需要先保存n节点地址(300),n节点地址存放在m节点指针域,将此值赋值给x节点指针域。(x->next...
  • 这道题需要用到链表的创建与插入
  • LinkList* LinkListInsertSort(LinkList* pHead) { LinkList *pFirst = ... /* 原链表剩下未排序节点头指针 */ LinkList *pCurrInsert = (LinkList *)NULL; /* 无序链表中当前待插入节点 */ LinkList *pPrev
  • 最近遇到这样一个题: 删除一个非尾结点pos;在pos位置插入一个值为data的新...于是,首先我们应该写一个能找到pos结点的函数 PNode FindDataNode(PNode pHead, DataType data) 函数代码如下: PNode FindDataNode...
  • 师--链表的结点插入

    2017-03-28 21:12:26
    1链表结点的头部插入+链表结点的中间插入+链表结点的尾部插入sdut题目链接师–链表的结点插入 Time Limit: 1000MS Memory Limit: 65536KBProblem Description 给出一个只有头指针的链表和 n 次操作,每次...
  • 双向链表结点的插入

    千次阅读 2012-02-28 20:23:13
    // * ======================================== */ // * 程式实例: 4_3_2.c */ // * 双向链结串列内节点插入 */ // * ======================================== */ #include stru
  • 链表的输入数据(追加法)、查找结点插入结点 要求:给定链表的结点指针(head),要求分别定义函数append, search_list, insert_node方法,实现链表数据输入、查找和插入。 #include <stdio.h> #...
  • 想了半天没想出来,求一段代码参考一下
  • 1、在无头单链表一个非头结点插入一个结点2、逆置链表单链表结构以及Find函数参见 2016-1-2 13:56 发表博客void InsertFront(SListNode*pos, const DataType x) //在无头单链表一个非头结点插入一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,253
精华内容 2,501
关键字:

结点的插入链表