精华内容
下载资源
问答
  • 给定一批严格递增排列的整型数据,给定一个x,若x不存在,则插入x,要求插入后保持有序。存在则无需任何操作。 输入格式: 输入有两行: 第一个数是n值,表示链表中有n个数据。后面有n个数,分别代表n个数据。 第二行...

    给定一批严格递增排列的整型数据,给定一个x,若x不存在,则插入x,要求插入后保持有序。存在则无需任何操作。

    输入格式:
    输入有两行: 第一个数是n值,表示链表中有n个数据。后面有n个数,分别代表n个数据。 第二行是要插入的数。

    输出格式:
    输出插入后的链表数据,以空格分开。行末不能有多余的空格。

    输入样例1:
    在这里给出一组输入。例如:

    5 1 3 6 9 11
    4
    结尾无空行
    输出样例1:
    在这里给出相应的输出。例如:

    1 3 4 6 9 11
    结尾无空行
    输入样例2:
    在这里给出一组输入。例如:

    5 1 3 6 9 11
    3
    结尾无空行
    输出样例2:
    在这里给出相应的输出。例如:

    1 3 6 9 11
    结尾无空行
    作者
    陈晓梅
    单位
    广东外语外贸大学
    代码长度限制
    16 KB
    时间限制
    400 ms
    内存限制
    64 MB

    #include <stdio.h>
    
    /* run this program using the console pauser or add your own getch, system("p
    展开全文
  • #include<stdio.h> #include<stdlib.h> #include<stdbool.h> //结点框架 ...//创建链表 Node* createList() { Node* headNode = (Node*)malloc(sizeof(Node)); headNode->next

    题目:
    给定一批严格递增排列的整型数据,给定一个x,若x不存在,则插入x,要求插入后保持有序。存在则无需任何操作。

    输入格式:
    输入有两行: 第一个数是n值,表示链表中有n个数据。后面有n个数,分别代表n个数据。 第二行是要插入的数。

    输出格式:
    输出插入后的链表数据,以空格分开。行末不能有多余的空格。

    输入样例1:
    在这里给出一组输入。例如:

    5 1 3 6 9 11
    4
    输出样例1:
    在这里给出相应的输出。例如:

    1 3 4 6 9 11

    #include<stdio.h>
    #include<stdlib.h>
    #include<stdbool.h>
    //结点框架
    typedef int Data;
    typedef struct _Node
    {
    	struct _Node* next;
    	Data data;
    }Node;
    //创建链表
    Node* createList()
    {
    	Node* headNode = (Node*)malloc(sizeof(Node));
    	headNode->next = NULL;
    	headNode->data = -1;
    	return headNode;
    }
    //创建结点
    Node* createNode(Data data)
    {
    	Node* newNode = (Node*)malloc(sizeof(Node));
    	newNode->next = NULL;
    	newNode->data = data;
    	return newNode;
    }
    //头插
    void insertByHead(Node* headNode, Data data)
    {
    	Node* newNode = createNode(data);
    	if (newNode == NULL)
    	{
    		return;
    	}
    	newNode->next = headNode->next;
    	headNode->next = newNode;
    
    }
    void List(Node* list, int a[], int n)
    {
    	Node* r = list;
    	Node* s = NULL;
    	for (int i = 0; i < n; i++)
    	{
    		s = createList();
    		s->data = a[i];
    		r->next = s;
    		r = s;
    	}
    	r->next = NULL;
    }
    //打印
    void insertByHead1(Node* headNode, Data data)
    {
    	Node* newNode = createNode(data);
    	newNode->data = data;
    	Node* p = headNode;
    	Node* s = headNode->next;
    	if (p->next == NULL)
    	{
    		newNode->next = NULL;
    		p->next = newNode;
    		p = newNode;
    		return;
    	}
    	while (s->data < newNode->data && s->next != NULL)
    	{
    		p = p->next;
    		s = s->next;
    	}
    	if (s->data == newNode->data)
    	{
    		free(newNode);
    		return;
    	}
    	if (s->data > newNode->data)
    	{
    		newNode->next = p->next;
    		p->next = newNode;
    		return;
    	}
    	if (s->next == NULL)
    	{
    		s->next = newNode;
    		newNode->next = NULL;
    		return;
    	}
    
    }
    void print(Node* headNode)
    {
    	Node* pMove = headNode->next;
    	int count = 0;
    	while (pMove)
    	{
    		if (count != 0)
    		printf(" ");
    		printf("%d", pMove->data);
    		pMove = pMove->next;
    		count++;
    	}
    }
    int main()
    {
    	Node* list = createList();
    	int a[100];
    	int n, data1;
    	scanf("%d", &n);
    	for (int i = 0; i < n; i++)
    	{
    		scanf("%d", &a[i]);
    	}
    	List(list, a, n);
    	scanf("%d", &data1);
    	insertByHead1(list, data1);
    	print(list);
    	return 0;
    }
    
    展开全文
  • PTA 7-4 在有序链表中插入数据 (20分)

    千次阅读 2020-10-11 14:51:57
    给定一批严格递增排列的整型数据,给定一个x,若x不存在,则插入x,要求插入后保持有序。存在则无需任何操作。 输入格式: 输入有两行: 第一个数是n值,表示链表中有n个数据。后面有n个数,分别代表n个数据。 第二行...

    给定一批严格递增排列的整型数据,给定一个x,若x不存在,则插入x,要求插入后保持有序。存在则无需任何操作。

    输入格式:
    输入有两行: 第一个数是n值,表示链表中有n个数据。后面有n个数,分别代表n个数据。 第二行是要插入的数。

    输出格式:
    输出插入后的链表数据,以空格分开。行末不能有多余的空格。

    输入样例1:
    在这里给出一组输入。例如:

    5 1 3 6 9 11
    4
    

    输出样例1:
    在这里给出相应的输出。例如:

    1 3 4 6 9 11
    

    输入样例2:
    在这里给出一组输入。例如:

    5 1 3 6 9 11
    3
    

    输出样例2:
    在这里给出相应的输出。例如:

    1 3 6 9 11
    

    AC代码

    #include<bits/stdc++.h>
    using namespace std;
    
    template <typename DataType>
    struct Node
    {
        DataType data;               //数据域
        Node<DataType> *next;       //指针域
    };
    
    template <typename DataType>
    class LinkList
    {
    public:
        LinkList();                      //无参构造函数,建立只有头结点的空链表
        LinkList(DataType a[], int n);       //有参构造函数,建立有n个元素的单链表
        ~LinkList();                     //析构函数
        int Length();                     //求单链表的长度
        void Insert(DataType x);       //插入操作,第i个位置插入值为x的结点
        void PrintList( );                  //遍历操作,按序号依次输出各元素
    private:
        Node<DataType> *first;           //单链表的头指针
    };
    
    template <typename DataType>
    LinkList<DataType> :: LinkList( )
    {
        first = new Node<DataType>;              //生成头结点
        first->next = nullptr;                      //头结点的指针域置空
    }
    
    template <class DataType>
    LinkList<DataType> :: ~LinkList( )
    {
        Node<DataType> *q = NULL;
        while (first != NULL)        //释放单链表的每一个结点的存储空间
        {
            q = first;                 //暂存被释放结点
            first = first->next;         // first指向被释放结点的下一个结点
            delete q;
        }
    }
    template <typename DataType>
    void LinkList<DataType> :: PrintList( )
    {
        int flag=0;
        Node<DataType> *p = first->next;                //工作指针p初始化
        while (p!= nullptr)
        {
            if(flag==0){
                cout << p->data;
                flag=1;
            }else{
                cout << " "<< p->data ;
            }
            p = p->next;                 //工作指针p后移,注意不能写作p++
        }
        cout<<endl;
    
    }
    
    /*插入函数*/
    template <typename DataType>
    void LinkList<DataType> :: Insert(DataType x)
    {
        Node<DataType> *Z = new Node<DataType>;
        Z->data = x;
        Node<DataType> *p = first, *s = first->next;
        //工作指针p指向要插入的前一个结点
        //s为p之后的一个结点,判断是否与要插入的值相等
        
        if (p->next == NULL)//链表为空链表
        {//要插入的元素放在开头
            Z->next = NULL;
            p->next = Z;
            p = Z;
            return;
        }
        
        while (s->data <Z->data&&s->next!=nullptr)//查找第i – 1个结点
        {
            p = p->next;
            s=s->next;
        }
    
        if(s->data == Z->data){//元素已存在
            delete Z;//删除要插入的结点
            return;
        }    
        if(s->data>Z->data){
        Z->next = p->next; //将结点Z插入到结点p之后
        p->next = Z;
        return;
        }
        if(s->next==nullptr){//找到链表结尾了,也找不到第i-1个结点
            s->next=Z;//将结点插在最后
            Z->next=nullptr;
            return;
        }
    }
    
    template <typename DataType>
    LinkList<DataType> :: LinkList(DataType a[ ], int n)
    {
        first = new Node<DataType>;                    //生成头结点
        Node<DataType> *r = first, *s = nullptr;           //尾指针初始化
        for (int i = 0; i < n; i++)
        {
            s = new Node<DataType>;
            s->data = a[i];
            r->next = s;
            r = s;                 //将结点s插入到终端结点之后
        }
        r->next = nullptr;        //单链表建立完毕,将终端结点的指针域置空
    }
    
    
    int main( )
    {
        int a[10000];
        int i,n;
        cin>>n;
        for(i=0;i<n;i++){
            cin>>a[i];
        }
        LinkList<int> L(a,n);
        int b;
        cin>>b;
        L.Insert(b);
        L.PrintList();
        return 0;
    }
    
    展开全文
  • 有序链表插入

    千次阅读 2017-11-07 20:36:28
    已知一个递增有序链表L(带头结点,元素为整数),编写程序将一个新整数插入到L,并保持L的有序性。其中单链表的类型定义参考如下: typedef int elementType; typedef struct lnode { elementType data; ...

    7-1 有序链表的插入(20 分)

    已知一个递增有序链表L(带头结点,元素为整数),编写程序将一个新整数插入到L中,并保持L的有序性。其中单链表的类型定义参考如下:

    typedef int elementType;

    typedef struct lnode

    { elementType data;

    struct lnode *next;

    }Lnode,* LinkList;

    输入格式:

    输入分三行

    第一行 元素个数

    第二行 元素的值,元素间用空格分隔。

    第三行 待插入的元素值

    输出格式:

    在一行中输出有序链表元素值,每个元素前输出一个空格以便与相邻元素分隔。

    输入样例:

    5
    1 3 5 7 9
    4
    

    输出样例:

     1 3 4 5 7 9
    
    以下为代码:

    #include <stdio.h>
    #include <stdlib.h>
    
    //函数状态码定义
    #define TRUE        1
    #define FALSE       0
    #define OK          1
    #define ERROR       0
    #define INFEASIBLE -1
    #define OVERFLOW   -2
    
    typedef int Status;
    typedef int ElemType;
    
    typedef struct LNode{
        ElemType data;
        struct LNode *next;
    }LNode, *LinkList;//单链表的结构体定义
    
    Status LinkListCreate_CL(LinkList &CL);
    void ListPrint_CL(LinkList CL);
    Status LinkListInsert_CL(LinkList &CL,ElemType e);
    
    Status LinkListCreate_CL(LinkList &CL)
    {
        LNode *curPtr, *rearPtr;
        CL = (LNode*)malloc(sizeof(LNode));
        if(!CL)
            exit(OVERFLOW);
        CL->next = NULL;
        curPtr = CL;
        rearPtr = CL;
        //头节点的尾指针和当前指针都指向头节点
        int TheNumberOfElement;
        scanf("%d", &TheNumberOfElement);
        for(int i = 0; i < TheNumberOfElement; i++)
        {
            curPtr = (LNode*)malloc(sizeof(LNode));
            if(!curPtr)
                exit(OVERFLOW);
            scanf("%d", &curPtr->data);
            rearPtr->next = curPtr;
            rearPtr = curPtr;//连接节点
        }
        rearPtr->next = NULL;//最后一个节点的尾指针赋空
        return OK;
    }
    void ListPrint_CL(LinkList CL)
    {
        LNode *p = CL->next;
        while(p)
        {
            printf("%d ", p->data);
            p = p->next;
        }
        printf("\n");
    }
    Status LinkListInsert_CL(LinkList &CL,ElemType e)
    {
        LNode *curPtr = CL->next, *rearPtr = CL, *temPtr;
        temPtr = (LNode*)malloc(sizeof(LNode));
        if(!temPtr)
            exit(OVERFLOW);
        temPtr->data = e;
        temPtr->next = NULL;
        if(curPtr == NULL)
        {
            rearPtr->next = temPtr;
            temPtr->next = NULL;
            return OK;
        }
        while(curPtr)
        {
            if(curPtr->data >= e)
            {
                rearPtr->next = temPtr;
                temPtr->next = curPtr;
                return OK;
            }
            rearPtr = curPtr;
            curPtr = curPtr->next;
        }
        curPtr->next = temPtr;
        temPtr->next = curPtr;
        return OK;
    }
    
    int main()
    {
        LinkList CL;
        ElemType elem;
        if(LinkListCreate_CL(CL) != OK)
        {
            printf("InitList_Sq: 初始化失败!!!\n");
            return -1;
        }
        scanf("%d", &elem);
        LinkListInsert_CL(CL,elem);
        ListPrint_CL(CL);
        return 0;
    }
    



    展开全文
  • 有序链表插入函数

    2019-06-16 21:43:04
    创建一个节点 ...调用有序链表插入函数: //插入到一个有序链表。函数的参数是一个指向链表根指针的指针,以及一个需要插入的新值 result=sll_insert(&root,12); 插入函数1 #include <st...
  • //头部插入 } else{ s->next=q;p->next=s; } return head; } void printList(linklist *head){ linklist *t; t=head; if (t==NULL) printf("这是一个空列表\n"); while (t!=NULL){ printf("%d ",t->...
  • 有序链表插入(PTA)

    千次阅读 2019-03-04 14:00:34
    已知一个递增有序链表L(带头结点,元素为整数),编写程序将一个新的整数差入到L,并保持 L的有序性。其中单链表的类型定义参考如下: typedef struct elementType; typedef struct Inode{ elementType data; ...
  • PTA 7-4 有序链表插入 (20 分)

    千次阅读 2019-05-22 08:12:44
    已知一个递增有序链表L(带头结点,元素为整数),编写程序将一个新整数插入到L,并保持L的有序性。 其中单链表的类型定义参考如下: typedef int elementType; typedef struct lnode { elementType data; ...
  • 如果一个有序数组,你想插入一个数据,还需要把其后所有元素往后移一位。 那么有没有一个比较好的数据结构可以实现简单便捷的插入操作呢? 那就是链表链表由两个部分组成,前面的部分为数据部分,用来存储...
  • 已知一个递增有序链表L(带头结点,元素为整数),编写程序将一个新整数插入到L,并保持L的有序性。 其中单链表的类型定义参考如下: ...一行输出有序链表元素值,每个元素前输出一个空格以便
  • 创建链表插入数据有序

    千次阅读 2016-08-28 15:20:54
    "读入需要插入数据:" ); scanf( "%d" , & a); t = head; while (t != NULL ) { if (t -> next == NULL || t -> next -> data > a) { struct node * d = (struct node * )malloc...
  • 这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何...在有序单链表L中插入数值x,仍然有序。(输入单链表数值时需要从小到大输入) 欢迎使用Markdown编辑器 #include
  • 下列给定程序已建立一个带头结点的单向链表,链表中各节点按节点数据数据递增有序链接。函数fun的功能是:把形参x的值放入一个新节点并插入列表使插入后各节点数据数据仍保持递增有序。  请程序的...
  • 双向链表——有序双向链表中插入节点
  • 1、已知带头结点的动态单链表 L 的结点是按整数值递增排序的,试写一 算法将值为 x 的结点插入到表 L ,使 L 仍然有序。要求算法的时间复杂度为 O(n),空间复杂度为 O(1)。 2、设计一算法,逆置带头结点的动态...
  • 题目:给定一个整数num,如何节点有序的环形链表中插入一个节点值为num的节点,并保证这个环形链表依然有序。(假如链表是升序) 解决思路: 1.如果链表为空,则开辟一个节点,让后让他自己指向自己,然后返回该...
  • 将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表不允许有重复的数据。 #include #include typedef struct list { int data; struct...
  • 编写算法实现:一个非递减有序链表中插入一个值为x的元素,使插入后的链表仍为非递减有序。
  • 循环有序链表中插入一个新值。例如:插入7之后算法: 为新插入的节点分配内存,并将数据放在新分配的节点。让指向新节点的指针是new_node。内存分配之后,以下是需要处理的三种情况。1)链接为空: a)因为...
  • 编写非递减有序链表中插入一个元素使链表元素仍有序的函数,并利用该函数建立一个非递减有序单向链表 #include<bits/stdc++.h> #define RESULT int #define OK 1 #define ERROR 0 using namespace std; ...
  • 数据结构与算法-有序单链表的插入

    千次阅读 2019-03-18 10:58:20
    //有序链表插入插入以后仍然有序 #include “slnklist.h” void insert(linklist L,datatype x) { //链表的查找和插入 linklist p,p1,p2; p=L->next; p2=L; p1=(linklist)malloc(sizeof(Lnode)); p1->...
  • 在有序链表中插入元素时,最好设置两个指针,一前一后, cur指针负责比较大小,pre指针负责定位插入位置的前驱。 #include using namespace std;typedef struct TNode { int data; struct TNode *next; }TNode;...
  • 双向链表有序添加的实现 public void addByOrder(HeroNode2 node... //头节点的情况此时链表没有数据所以直接插入就好 if (head.next == null) { head.next = node; node.pre = head; //直接结束掉此方法 return;
  • 有序链表插入元素

    千次阅读 2015-07-05 14:59:30
    在有序链表中插入元素时,最好设置两个指针,一前一后,后面指针负责比较大小,前面的指针负责插入操作。#include "stdafx.h" #include #include <stdlib.h>struct vNode { int value; struct vNode* next; }; ...
  • 一个有序(按非递减顺序)的链表中插入一个元素为x的结点,使插入后的链表仍然有序链表数据域为整型数,初始时输入6个元素)。 程序运行示例如下: 输入数组6个元素的值。 12 23 34 45 56 67 此链表各个结点的数据...
  • 双向链表有序插入

    千次阅读 热门讨论 2020-03-04 19:53:47
    今天无意间翻开了数据结构,忽然扫到了双向链表,就想着重新把代码码一遍练练手。三两分钟就写完了,运行时就尴尬了。发现没有输出。 于是我就debug了一下,就发现,每次插入的元素的pre竟然是元素本身经过调试后,...
  • 题目:将一个升序链表中插入一个元素,使原链表仍然升序 #include<stdio.h> #include<stdlib.h> typedef struct node{ int data; struct node * next; }ElemSN;//定义结构体单元 ElemSN * createlink...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 100,586
精华内容 40,234
关键字:

在有序链表中插入数据