精华内容
下载资源
问答
  • 已知有两个按元素值递增有序的顺序A和B,设计一个算法将A和B的全部元素归并为一个元素值递增有序的顺序C。
  • 已知线性表中元素以值递增有序排列,并以单链表作为存储结构 设计一个算法,删除中值相同的多余元素 使得操作后中所用元素值均不同,同时释放被删除的结点空间

    /* 已知线性表中元素以值递增有序排列,并以单链表作为存储结构
    * 设计一个算法,删除表中值相同的多余元素
    * 使得操作后表中所用元素值均不同,同时释放被删除的结点空间
    */

    #include<stdio.h>
    #include<stdlib.h>
    #define OK 1
    #define ERROR 0
    
    typedef int ElemType;
    typedef int Status;
    typedef struct Node
    {
        ElemType data;
        struct Node * next;
    }Node,*LinkList;
    
    //单链表的初始化
    Status InitLinkList(LinkList * L)
    {
        (*L)=(LinkList)malloc(sizeof(Node));
        if((*L)==NULL)
        {
            printf("内存分配失败!\n");
            return 0;
        }
        (*L)->next=NULL;
        return OK;
    }
    
    //单链表的建立
    Status Create(LinkList * L,int n)
    {
        LinkList P,Q;
        ElemType Elem;
        Q=(*L);
        printf("请按递增顺序输入元素:\n");
        for(int i=0;i<n;i++)
        {
            P=(LinkList)malloc(sizeof(Node));
            scanf("%d",&Elem);
            P->data=Elem;
            Q->next=P;
            Q=P;
        }
        P->next=NULL;
        return OK;
    }
    
    
    //删除结点
    Status Delete(LinkList * L,int Location)
    {
        LinkList Q,P;
        int count=0;
        int k=Location+1;
        Q=(*L);
        P=(*L)->next;
        while(P->next)
        {
            Q=Q->next;
            P=P->next;
            count++;
            if(count==Location)
            {
                Q->next=P->next;
            }
        }
        return OK;
    }
    
    
    //定位删除结点的位置并删除
    Status Locate(LinkList * L)
    {
        LinkList First,Second;
        int count=1;
        First=(*L)->next;
        Second=(*L)->next->next;
        while(Second)
        {
            if(First->data==Second->data)
            {
                Delete(L,count);
                Second=Second->next;
            }
            else
            {
                count++;
                First=First->next;
                Second=Second->next;
            }
    
        }
        return OK;
    }
    
    
    void Print(LinkList * L)
    {
        LinkList P;
        P=(*L)->next;
        while(P)
        {
            printf("%d ",P->data);
            P=P->next;
        }
        printf("\n");
    }
    
    
    
    int main()
    {
        LinkList L;
        int Number;
        InitLinkList(&L);
        printf("请输入元素个数:\n");
        scanf("%d",&Number);
        Create(&L,Number);
        printf("输出链表:\n");
        Print(&L);
        Locate(&L);
        printf("输出去掉相同元素后链表:\n");
        Print(&L);
        return 0;
    }

    运行结果

    展开全文
  • 已知顺序中的元素元素值非递减有序排列,编写一个算法,删除顺序中多余的值相同的元素。 运行截图: 代码: #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR -1 #define ...

    已知顺序表中的元素按元素值非递减有序排列,编写一个算法,删除顺序表中多余的值相同的元素。
    运行截图:
    在这里插入图片描述
    代码:

    #include<stdio.h>
    #include<stdlib.h>
    #define OK 1
    #define ERROR -1
    #define OVERFLOW -2
    #define MAXSIZE 10;
    typedef int Status;
    typedef int ElemType;
    typedef struct 
    {
    	ElemType *elem;
    	int length;
    	int listsize;
    }SqList;
    Status InitList(SqList &L)
    {
    	
    	L.elem=new ElemType[100];
    	L.length =10;
    	return OK;
    		
    }
    Status DeleteList(SqList &L)
    {
    	int j=0,k,i,m;
    	i=L.elem[j];
    	while(j<L.length)
    	{
    		for(k=0;k<L.length;k++)
    			if(i==L.elem[k]&&k!=0)
    			{
    		for(m=k;m<L.length;m++)
    			L.elem[m]=L.elem[m+1];
    		L.length=L.length-1;
    			}
    		j=j+1;
    		i=L.elem[j];
    	}
    
    	return OK;
    
    
    }
    
    
    
    int main()
    {
    	SqList L;
    	InitList(L);
    
    	int i,j;
    	printf("请输入10个数(中间用空格):");
    	for(i=0;i<10;i++)
    	{
    		scanf("%d",&L.elem[i]);
    		printf(" ");
    	}
    	printf("\n");
    		DeleteList(L);
    		printf("删除成功!");
    		printf("\n");
    		for(i=0;i<L.length;i++)
    			printf("%5d",L.elem[i]);
    		printf("\n");
    
    }
    
    展开全文
  • 已知顺序元素值递增有序。用算法实现将元素x查到中适当的位置上,以保持顺序有序性。 第种写法: //已知顺序元素值递增有序。用算法实现将元素x查到中适当位置上,以保持顺序有序性 #include...

    已知顺序表中元素值递增有序。用算法实现将元素x查到表中适当的位置上,以保持顺序表的有序性。

    第一种写法:

    //已知顺序表中元素值递增有序。用算法实现将元素x查到表中适当位置上,以保持顺序表的有序性
    #include"stdio.h"
    #define DATATYPE1 int
    #define MAXSIZE 100
    typedef struct
    {
    	DATATYPE1 datas[MAXSIZE];
    	int last;
    }SEQUENLIST;
    
    void insert_x_seqlist(SEQUENLIST *a,int x)
    {//在有序表中插入一个x,插入完仍有序
    	int i;
    	i=a->last;
    	while(x<a->datas[i])
    	{
    		a->datas[i+1]=a->datas[i];
    		i--;
    	}
    	a->datas[i+1]=x;
    	a->last++;
    }
    void print_seqlist(SEQUENLIST *a)
    {//依次打印顺序表a中的所有元素
    	int i;
    	printf("表中各元素为:");
    	for(i=1;i<=a->last;i++)
    	{
    		printf("%5d",a->datas[i]);
    	}
    	printf("\n");
    }
    main()
    {
    	SEQUENLIST a;
    	int n=5,i,x;
    	printf("构造含有%d元素有序表:",n);
    	printf("\n请输入一个整数:");
    	scanf("%d",&x);
    	a.datas[1]=x;
    	a.last=1;
    	i=2;
    	while(i<=n)
    	{
    		print_seqlist(&a);
    		printf("\n请输入一个整数:");
    		scanf("%d",&x);
    		insert_x_seqlist(&a,x);
    		i++;
    	}
    	printf("\n含有%d个元素的有序表:\n",n);
    	print_seqlist(&a);
    }
    

    第二种写法:

    //2-2insert_sortSqlist-2.c
    #include"stdio.h"
    #define DATATYPE1 int
    #define MAXSIZE 100
    typedef struct
    {
    	DATATYPE1 datas[MAXSIZE];
    	int last;
    }SEQUENLIST;
    
    void insert_x_seqlist(SEQUENLIST *a , int x)
    {//在有序表中插入一个x,插入完仍有序
    	int i;
    	i=a->last;
    	while(x<a->datas[i])
    	{      
    		a->datas[i+1]=a->datas[i];      
    		i--;  
    	}
    	a->datas[i+1]=x;
        a->last++;
    }
    int create_sortedlist(SEQUENLIST *a,int n)
    {
    	void print_seqlist(SEQUENLIST *a);
    	int x,i=1;
    	
    	if(n>=1)
    	{
    		printf("请输入第%d个整数:",i);
    		scanf("%d",&x);
    		a->datas[1]=x;
    		a->last=1;
    		print_seqlist(a);
    		i=2;
    		while(i<=n)
    		{
    			printf("请输入第%d个整数:",i);
    			scanf("%d",&x);
    			insert_x_seqlist(a,x);	
    			print_seqlist(a);
    			i++;
    		}
    		return 1;
    	}
    	else
    		return 0;
    
    }
    
    void print_seqlist(SEQUENLIST *a)
    {//依次打印顺序表a中的所有元素
    	int i;
    	printf("表中各元素为:");
    	for(i=1;i<=a->last ;i++)
    	{
    		printf("%5d",a->datas[i]); 
    	}
    	printf("\n");
    }
    
    
    main()
    {
    	SEQUENLIST a;
    	int n=5;	
    	printf("构造含有%d元素有序表:\n",n);
    	if(create_sortedlist(&a,n)==1)	
    	{
    		printf("\n含有%d个元素有序表:\n",n);
    		print_seqlist(&a);
    	}
    	else
    		printf("构造失败\n");
    	
    }
    
    

    关注下面这个关注号,了解更多信息。
    热爱编程的小白
    头顶渐突终不悔,代码道出我的爱。

    展开全文
  • 已知一个顺序L, 其中的元素递增有序排列,设计一个算法,插入一个元素x (x为int 后保持该顺序仍然递增有序排列(假设插入操作总能成功)。 二、【题目分析】: 由题干可知,解决本题需完成两个操作: 1)找出可以让...

    一、【题目描述】:

    已知一个顺序表L, 其中的元素递增有序排列,设计一个算法,插入一个元素x (x为int
    后保持该顺序表仍然递增有序排列(假设插入操作总能成功)。

    二、【题目分析】:

    由题干可知,解决本题需完成两个操作:
    1)找出可以让顺序表保持有序的插入位置。
    2)将步骤1)中找出的位置上以及其后的元素往后移动一个位置,然后将x放至腾出的位置上。

    三、【问题解答】

    ①因为顺序表L中的元素是递增排列的,所以可以从小到大逐个扫描表中元素,当找到第一
    个比x大的元素时,将x插在这个元素之前即可。

    int findE(Sqlist L,int x){
    int i;
    for(i=0;i<L.length;++i){
    	if(x<L.data[i]){
    		return i;
    		}
    	}
    	return i;
    }
    

    ②找到插入位置之后,将插入位置及其以后的元素向后移动一个元素的位置即可。先移动最右边的元素。

    void insertE(Sqlist &L,int x){
    int p,i;
    p=findE(L,x);
    for(i=L.length-1;i>=p;--i)
    L.data[i+1]=L.data[i];
    L.data[p]=x;
    L.length++;
    }
    
    展开全文
  • void Insert(List L, int x) { int i,j; for(i=0;L->Data[i] < x&&i<=L->Last;i++) ; for(j=L->Last; j>=i; j--) L->Data[j+1]=L->Data[j]; L->...}
  • 个有序链表合并(新不含重复元素)(记录学习过程) 题目: 已知非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的非降序链表S3。 要求S3中没有重复元素。 输入格式: 输入分两行,分别在每行给出由...
  • 先寻找值大于等于k1的第一个元素(第一个删除的数据元素),然后寻找值大于k2的第一个数据元素(最后一个删除的下一个元素),将后面所有结点前移即可。 核心算法: #define MaxSize 50 //长度的初始定义 typedef ...
  • 文章目录1、顺序插入并递增有序已知顺序L中的元素递增有序排列,设计算法将元素x插入到L中并保持L仍递增有序。2、删除顺序表元素在顺序中删除所有元素值为x的元素,要求空间复杂度为O(1)。3、顺序逆置以...
  • C++ 7-2 两个有序链表合并(新不含重复元素) (20 分) 已知非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的非降序链表S3。 要求S3中没有重复元素。 输入格式: 输入分两行,分别在每行给出由若干正...
  • 例如:L=1,3,4 那么将P中第1,3,4个元素打印出来 #ifndef List #include using namespace std; struct listNode; typedef int ElementType; typedef struct listNode *PtrToNode; typedef PtrToNode List; ...
  • 试设计一个算法将它们合并到单链表lc中,且lc仍然有序,再输出 。 */ # include <iostream> # include <stdio.h> # include <stdlib.h> using namespace std; typedef struct Node { int elem;...
  • 在154个元素组成有序表进行二分法查找,可能的比较次数为 正确答案: B C D 你的答案: B (错误) 10 8 4 1 添加笔记 求解答(6) 收藏 纠错 折半查找过程可用二叉树...
  • //将两个有序链表并为一个有序链表算法,该程序也可以cFree环境运行。 // c1.h (程序名) #include<string.h> #include<ctype.h> #include<malloc.h> // malloc()等 #include<limits.h> //...
  • 已知非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的非降序链表S3。 要求S3中没有重复元素。 输入格式: 输入分两行,分别在每行给出由若干正整数构成的非降序序列,用−1表示序列的结尾(−1不属于...
  • 给定k个有序表(不妨假设均为升序),求这k个有序表中最小的n个元素,这类问题称为多路归并问题。 对于这类问题,考虑先取出每个有序表中的最小的元素,在取出的这些元素中的最小值即为所有元素的最小值,必然要被选中...
  • 已知顺序中的元素依值递增有序排列,要求删除中所有值相同的多余元素(使得操作后的顺序中所有元素的值均不相同) # include <stdio.h> # include <stdlib.h> # define initsize 20//初始分配量 ...
  • 编写一个算法将la和lb归并到新的顺序lc中,要求lc中的元素也是非递减有序排列。 0.c #include"seqlist_def.h" #include"stdio.h" int merge_seqlist(SEQUENLIST *la, SEQUENLIST *lb, SEQUENLIST *lc) { int...
  • 小白今天刚入门数据结构,正在学习《数据结构高分笔记》,...题目要求:已知递增有序的单链表A,B,元素个数分别m,n,分别存储一个集合,请设计算法,求出A与B的差集,将结果保存在A中,保持元素递增有序。 #in
  • 有序链表中插入元素时,最好设置两指针,后, cur指针负责比较大小,pre指针负责定位插入位置的前驱。 #include using namespace std;typedef struct TNode { int data; struct TNode *next; }TNode;...
  • 将两个有序链表合成一个有序链表

    千次阅读 2017-09-14 20:01:34
     题目:已知有两个有序的单链表,其头指针分别为head1和head2,实现将这两链表合并的函数:  Node* ListMerge(Node *head1,Node *head2)  这算法很像我们排序算法中的归并排序,只能说“很像”,因为...
  • 将两个有序链表合并成一个链表

    万次阅读 多人点赞 2018-08-04 17:05:37
    创建好两个有序链表之后,将两个链表的头结点进行比较,小的那个作为合并后的链表的头结点,同时,创建两个指针分别指向两个链表的的头结点或头结点的下一个节点,当两个链表进行比较的元素都不为空的话,依次从下到...
  • 已知非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的非降序链表S3。 要求S3中没有重复元素。 输入格式: 输入分两行,分别在每行给出由若干正整数构成的非降序序列,用−1表示序列的结尾(−1不属于这...
  • 已知非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的非降序链表S3。 要求S3中没有重复元素。 输入格式: 输入分两行,分别在每行给出由若干正整数构成的非降序序列,用−1表示序列的结尾(−1不属于这...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,988
精华内容 8,795
关键字:

已知11个元素的有序表