精华内容
下载资源
问答
  • 2018-11-01 17:19:56

    代码:

    #include <stdio.h>
    
    /*
    题目:数据结构题集17页2.11
    设顺序表中数据元素递增有序,试写一算法,将x插入到顺序表的适当位置上,以保持该表的有序性
    算法:逆序遍历顺序表找合适的插入new_elem的位置,并将其插入
    */
    
    #define maxlen 50
    typedef struct{
        int arr[maxlen];
        int length;
    }Seqlist;
    
    void print_SQ(Seqlist list){
        for(int i=0; i<list.length;i++){
            printf("%d  ",list.arr[i]);
        }
        printf("\n");
    }
    
    int main(void)
    {
        Seqlist list;
        list.arr[0]=1;list.arr[1]=6;list.arr[2]=9;list.arr[3]=30;
        list.length = 4;
    
    
        if(list.length+1 > maxlen){
            return -1;
        }
        int i;
        //要插入链表的数值
        int new_elem = 6;
        //更新表长
        ++list.length;
        //如下是插入new_elem操作:逆序遍历顺序表找合适的插入new_elem的位置,并将其插入
        for(i=list.length-1;i>=0;i--){
            if(list.arr[i] >= new_elem){
                //当前元素向后移动赋值
                list.arr[i+1] = list.arr[i];
            }else{
                list.arr[i+1] = new_elem;
                break;
            }
    //        print_SQ(list);
        }
        //打印顺序表
        print_SQ(list);
    
        return 0;
    }
    

     

    更多相关内容
  • 按照x的值,找到顺序表中一个比x大的元素的位置; int findElem(Sqlist L, int x) { int i; for(i = 0; i<L.length;i++) { if(x < L.data[i]) return i; } return i; } 2.主要函数2:元素后移...

    1.主要函数1:按元素值查找位置

    按照x的值,找到顺序表中第一个比x大的元素的位置;

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

    2.主要函数2:元素后移一位置

    将1中找出的位置上以及其后的元素往后移动一个位置,然后将x放到腾出的位置上。

    void insertElem(Sqlist &L, int x)
    {
    	int p,i;
    	p = findElem(L,x);
    	for(i=L.length-1;i>=p;--i)
    	{
    		L.data[i+1] = L.data[i];
    	}
    	L.data[p] = x;
        ++(L.length);
    
    }
    

    完整代码:

    #include <iostream>
    using namespace std;
    # define maxSize 100
    
    typedef struct
    {
    	int data[maxSize];
    	int length;
    
    }Sqlist;
    
    int findElem(Sqlist L, int x)
    {
    	int i;
    	for(i = 0; i<L.length;i++)
    	{
    		if(x < L.data[i])
    			return i;
    	}
    	return i;
    }
    
    void initList(Sqlist &L)
    {
    	L.length = 0;
    }
    
    void insertElem(Sqlist &L, int x)
    {
    	int p,i;
    	p = findElem(L,x);
    	for(i=L.length-1;i>=p;--i)
    	{
    		L.data[i+1] = L.data[i];
    		printf("移动的下标位置i = %d\n",i);
    	}
    	L.data[p] = x;
    	//表长要自增1,并且是先后移再插入x,最后增表长
        ++(L.length);  
    }
    
    int main(){
    	Sqlist L;
    	int i;
    	initList(L);
    	L.length = 8;
    	L.data[0] = 4;
    	L.data[1] = 5;
    	L.data[2] = 6;
    	L.data[3] = 7;
    	L.data[4] = 9;
    	L.data[5] = 13;
    	L.data[6] = 15;
    	L.data[7] = 22;
    	insertElem(L,12);
    	for (i=0;i<L.length;++i)
    	{
    		printf("L.data[%d]=%d\n",i,L.data[i]);
    	}
    	printf("L的表长=%d\n",L.length);
    
    	return 0;
    }
    

    总结:

    表长自增1,容易忘记。并且是先后移再插入x,最后增表长。这里的顺序问题要注意。

    容易犯错的地方:
    思考为何不先增表长,再后移再插入x

    展开全文
  • 直接上代码 ...#define LIST_INIT_SIZE 10//顺序存储空间的初始分配量 #define LISTINCREMENT 5// 顺序存储空间的分配增量 #define OVERFLOW 0 #define ok 1 typedef struct{ int *element;//...

    直接上代码

    #include<stdio.h>
    #include<stdlib.h>
    #define LIST_INIT_SIZE 10//顺序表存储空间的初始分配量
    #define LISTINCREMENT 5// 顺序存储空间的分配增量 
    #define OVERFLOW 0
    #define ok 1 
    typedef struct{
    	int *element;//顺序表的基地址 
    	int length;//顺序表的长度 
    	int listsize;//顺序表的存储空间 
    }Sqlist;
    //初始化一个顺序表
    int InitList(Sqlist *l){
    	l->element=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
    	if(!l->element){
    		printf("无法申请内存空间!\n");
    		exit(OVERFLOW);
    	}
    	l->length=0;//将长度初始化为0 
    	l->listsize=LISTINCREMENT;//初始存储容量 
    	return ok;
    } 
    //在某个位置插入一个元素
    int ListInsert(Sqlist *l,int i,int e) {
    	if(!l->length){//如果刚开始还没有元素,那就进行以下操作 
    		l->length++;
    		l->element[l->length-1]=e;
    		return ok;//这一步就是直接结束该函数 
    	}
    	else if(i<1||i>l->length+1){//这里为什么不是l->length,而是l->length+1呢? 
    		printf("输入的位置有误!\n");//l->length+1就表示在最后一个,这也算是插入,只不过是插在了最后一个位置,后面没有元素了 
    		return OVERFLOW;
    	}
    	if(l->length==l->listsize){//当刚开始的分配空间用完时,就要新开辟空间了 
    		int *newbase;
    		newbase=(int *)realloc(l->element,(l->listsize+LISTINCREMENT)*sizeof(int));
    		if(!newbase){
    			printf("申请内存失败!\n");
    			return OVERFLOW;
    		}
    		l->element=newbase;
    		l->listsize+=LISTINCREMENT;
    		//return ok;
    	}
    	int *p;
    	p=l->element+l->length-1;//将工作指针移到最后一个元素,注意要-1,因为在数组中,开始的下标为0 
    	while(p>=l->element+i-1)
    		*(p+1)=*p--;
    	l->element[i-1]=e;
    	l->length++;	
    	return ok;
    }
    //将元素插入顺序表中
    int Insert(Sqlist *l,int e){
    	int i=0,*p=l->element+l->length-1;
    	while(e<=l->element[i])
    		i++;
    	if(l->length==l->listsize){
    		int *newbase;
    		newbase=(int *)realloc(l->element,(l->listsize+LISTINCREMENT)*sizeof(int));
    		if(!newbase){
    			printf("无法申请内存!\n");
    			return OVERFLOW;
    		}
    		l->element=newbase;
    		l->listsize+=LISTINCREMENT;
    	}
    	while(p>=l->element+i)
    		*(p+1)=*p--;
    	l->element[i]=e;
    	l->length++;
    	return ok;
    } 
    //输出顺序表中的数据
    void OutList(Sqlist *l){
    	int i;
    	for(i=0;i<l->length;i++)
    		printf("%d ",l->element[i]);
    	printf("\n");
    } 
    int main(){
    	int flag=1,i=1,num;
    	Sqlist l;
    	InitList(&l);
    	printf("请按非递减顺序输入数据\n");
    	while(flag){
    		scanf("%d",&num);
    		ListInsert(&l,i,num);
    		i++;
    		printf("是否要继续输入?no 0,yes 1\n");
    		scanf("%d",&flag);
    	}
    	OutList(&l);
    	printf("请输入您要插入的数据\n");
    	scanf("%d",&num);
    	Insert(&l,num);
    	printf("最后的结果为:\n");
    	OutList(&l);
    	return 0;
    }
    
    展开全文
  • 刚开始学数据结构,还费了很多的时间才做完这实验0.0 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; //malloc函数头文件 #define false 0 #define true 1 #define LIST_INIT_SIZE 100 #...

    刚开始学数据结构,还费了很多的时间才做完这个实验0.0

    #include<stdio.h>
    #include<stdlib.h>    //malloc函数头文件
    #define false 0
    #define true 1
    #define LIST_INIT_SIZE  100
    #define LISTINCREMENT 10
    typedef struct{
    	int *elem;
    	int length;    //当前长度 
    	int listsize;//当前分配的存储容量 
    }SqList;
    
    bool InitList(SqList &L){  //数据表的创建
    	L.listsize = LIST_INIT_SIZE;
    	L.elem = (int *)malloc(L.listsize*sizeof(int));     //给顺序表创建动态空间
    	if (!L.elem){ //存储分配失败 
         return	false;
    	}
    	L.length = 0;
    	return true;
    }
    
    void InPut(SqList &L){
    	int n;
    	printf("初始状态顺序表的长度: (<100)\n");
    	scanf("%d", &n);
    	printf("请输入你要创建的顺序表:\n");
    	for (int i = 0; i < n; i++){
    		scanf("%d", &L.elem[i]);   //存入的值从数组0开始
    		L.length++;
    	}
    }
    
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>(L.listsize+1) ){
    		return false;
    	}
    	if(L.length>=L.listsize){
    		SqList M; 
    		M.elem=(int *)realloc(L.elem , (L.listsize + LISTINCREMENT)*sizeof(int)); 
    		if(!M.listsize) return false;
    		L.elem=M.elem;
    		L.listsize+= LISTINCREMENT;
    	}
    	for(int j=L.length-1;j>=i-1;j--){
    		L.elem[j + 1] = L.elem[j];
    	} 
    	L.length+=1;
    	L.elem[i-1]=e;
    	return true;
    }
    
    void ListTraverse(SqList &L){
    	for(int i=0;i<L.length;i++){
    		printf("%d, ",L.elem[i]);
    	}
    }
    
    int main(){
    	int p;
    	int y_num;
    	SqList L;
    	InitList(L);
    	InPut(L);//输入时就是非递减的
    	printf("请输入要插入的整数:\n");
    	scanf("%d",&y_num);
    	for(p=0;p<L.length;p++){
    		if(y_num<=L.elem[p]){
    			p=p+1;//0.0
    			ListInsert(L,p,y_num);
    			break;
    		}
    	}
    	if(y_num>L.elem[L.length-1]){
    		ListInsert(L,L.length+1,y_num);
    	}
    	ListTraverse(L);
    	return 0;
    } 
    

     

    展开全文
  • (1)设计一个算法,判断顺序L所有元素是否是递增有序的。 (2)设计一个算法,将顺序L的所有元素逆置,要求算法空间复杂度为O(1)。 (3)有一个非空整数顺序L,其中元素值可能重复出现,设计一个算法,...
  • 154个元素组成有序表进行二分法查找,可能的比较次数为() A:10 B:8 C:4 D:2答案:BCD别出新意的解题思路: 折半查找过程可用二叉树来描述,把有序表中间位置上的结点作为树的根结点,左子表和右子表...
  • 个有序链表合并(新不含重复元素)(记录学习过程) 题目: 已知两非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的非降序链表S3。 要求S3没有重复元素。 输入格式: 输入分两行,分别每行给出由...
  • 若是存在头结点的单链表,则不需要判断头结点,直接进行操作即可,头结点的... * @description:假设不头结点的单链表A,B为有序递增表,编写算法,从有序表A删除所有和有序表B相同的元素。 * @author: TAO *...
  • 实验目的 熟悉将算法转换成程序代码的过程,了解...(1)非递减有序的顺序表中插入一个元素x,保持顺序表有序性               #include&lt;stdio.h&gt; #include&lt;stdlib.h&g...
  • 数据结构_顺序表中插入元素_C语言版 头文件和定义结构体: #include<stdio.h> #include<stdlib.h> #define Initsize 10 //初始的数组长度 typedef struct{ //定义一个结构体(自己定义一个结构类型)...
  • /*有序顺序的插入*/ void InsertSqlist(Sqlist *L,Elemtype number) { int i; assert(L-&amp;gt;length &amp;lt; L-&amp;gt;Listsize); //创建长大于或等于初始分配量,则无法进行插入...
  • 将两个顺序存储的有序表A和B合成一个有序表C的算法 假设A、B和C的类型为下述SqList类型: #define maxlen 1000 typedef int elemtype typedef struct { elemtype elem[maxlen]; int len; }SqList; 设A和B的数据元素...
  • //算法思想:相同元素在有序表中位置连续,遍历顺序表,从第一个值开始向后判断。 //若相等则继续往后判断,若不相等则前移,删除掉前面相等的元素。 #include"head.h" bool del_same(SeqList& L) { if (L....
  • 154个元素组成有序表进行二分法查找,可能的比较次数为 正确答案: B C D 你的答案: B (错误) 10 8 4 1 添加笔记 求解答(6) 收藏 纠错 折半查找过程可用二叉树...
  • 假设有两元素值递增有序排列的线性表a和b,均以单链表作为存储结构,请编程实现将a和b归并成一元素值递减有序排列的线性表c(注意:非严格递减,也就是说本题的数据有可能相等),并要求利用原的...
  • 在一个递增有序的线性表,有数值相同的元素存在。若存储方式为单链表,设计算法,去掉数值相同的元素,使得表中不再有重复的元素。例如(7,1010,21,30,42,42,42,51,70)将变为(7,10,21,30,42,51,...
  • ( ) 【其它】任务4 一个gif 阔步 logo psd+jpg 2张 banner psd+jpg 2张 一共 5个 文件 【单选题】图示 圆截面, 点为形心,则( )。 【单选题】pick up 【单选题】图示截面图形对形心轴 的惯性矩 ( )。 IMG_2259[1].JPG...
  • 单链表练习题-向有序单链表插入元素并保持有序(C语言实现) 文章目录单链表练习题-向有序...​ 由于原来的链表已经有序,那么我们只需要一个指针就可以了。用指针p遍历链表,比较p当前所指元素和p后继的元素,如果要
  • 已知顺序表中元素元素值非递减有序排列,编写一个算法,删除顺序表中多余的值相同的元素。 运行截图: 代码: #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR -1 #define ...
  • 归并排序是多次将两个或两个以上的有序表合并成一个新的有序表。最简单的归并是直接将两个有序的子表合并成一个有序的表,即二路归并 二路归并的排序基本思想是:  将a[0……n-1]看成是n个长度为1的有序序列,...
  • 实现功能 在一个有序数组,查找想要查找的某个具体数值
  • 已知两非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的...在一输出合并后新的非降序链表,要求链表没有重复元素。数字间用空格分开,结尾不能有多余空格;若新链表为空,输出NULL。 输入样例: 这...
  • //currentAIndex用于记录A表中保留下来的元素在A表中的位置 for (int indexA = 0; indexA ; indexA++) { while (listA[indexA].compareTo(listB[indexB]) > 0) { indexB++; } if (listA[indexA].compareTo(listB...
  • A和B是两个单链表(带有表头节点),其中元素是递增有序的,设计一个算法,将A和B归并成一个按元素值非增减有序的链表C,C由链表A和B的节点组成 2. 思路分析: ① 我们知道头插法最终创建的链表的顺序与插入的顺序...
  • 给出在一个递增有序表A采用二分查找算法查找值为k的关键字的递归算法。 分析 即二分查找的算法。 代码 核心代码: /* 二分查找的核心算法 */ /* A[]指的是要查找的数组;low指的是开始下标;high指的是结束...
  • 首先输入一个正整数N(1≤N≤1000)和一个无重复元素的、从小到大排列的、N个元素有序表,然后屏幕上显示以下菜单(编号和选项)。 [1] Insert [2] Delete [3] Update [4] Query [Other option] End 用户可以...
  • 有序数组插入元素依然保持有序

    千次阅读 2021-03-28 16:20:24
    有序数组插入元素依然保持有序如何...//在有序表中插入元素,插入后数组依然有序 #include<iostream> using namespace std; int main() { int a[11] = {1,2,3,4,5,6,7,8,9,10}; int insert = 0; scanf("%
  • 已知一个顺序L, 其中的元素递增有序排列,设计一个算法,插入一个元素x (x为int 后保持该顺序仍然递增有序排列(假设插入操作总能成功)。 二、【题目分析】: 由题干可知,解决本题需完成两个操作: 1)找出可以让...
  • 废话不多说,直接上程序 #include <stdio.h> #include #define MaxSize 20 typedef int ElemType; typedef struct ...//为了方便,顺序的第一个位置不放值,也就是下标为0的 void CreateList...
  • //假设原始长为 5 printf("请输入顺序内的五数字:"); for(int i=0;i;i++) scanf("%d",&L.elem[i]); } // 按序插入x Status InsertX_B(SqList &L, int x){ if(L.length>=L.listsize) //判断满 { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 155,462
精华内容 62,184
关键字:

在一个10元素的有序表中