精华内容
下载资源
问答
  • 设顺序表中数据元素递增有序,试写算法,将x插入到顺序的适当位置上,以保持该有序性 算法:逆序遍历顺序找合适的插入new_elem的位置,并将其插入 */ #define maxlen 50 typedef struct{ int arr[maxlen...

    代码:

    #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;
    }
    

     

    展开全文
  • 若是存在头结点的单链表,则不需要判断头结点,直接进行操作即可,头结点的... * @description:假设不头结点的单链表A,B为有序递增表,编写算法,从有序表A删除所有和有序表B相同的元素。 * @author: TAO *...

    若是存在头结点的单链表,则不需要判断头结点,直接进行操作即可,头结点的存在是为了使单链表的增加、删除操作更加方便,从此例中可以清楚的看到。可以写一个带头结点的单链表进行比较。

    /**
     * @program: entrance_exam
     * @description:假设不头结点的单链表A,B为有序递增表,编写算法,从有序表A中删除所有和有序表B中相同的元素。
     * @author: TAO
     * @create: 2018-05-31 09:22
     **/
    /**算法思想:设计两个指针p,q分别指向A,B的第一个结点,接下来进行比较:
     *          如p指向的结点大于q所指向的结点,那么q指向B表的下一个结点
     *          若p指向的结点小于q所指向的结点,那么p指向A表的下一个结点
     *          若p所指向的结点等于q所指向的结点,那么则删除p所指向的结点,同时p,q均向后移动一位
     *  关键是在比较的第一个过程中,判断A表的第一个元素是否会被删除,加入判断语句。
     * */
    class LinkNode{
        //内部类定义结点
        class ANode{
            int data;
            ANode next=null;//定义下一个结点
            ANode(int newData){
                this.data=newData;
            }
        }
    
        private ANode head = null;
        private ANode temp = null;
    
        public  void insertList(int d){
            ANode node=new ANode(d);
            if(head==null){
                head=node;
                return;
            }
            ANode temp=head;
            while(temp.next!=null)
                temp=temp.next;
            temp.next=node;
        }
    
        public ANode getHead() {
            return head;
        }
    }
    public class Exercise12 {
        public static void main(String[] args) {
            LinkNode linkNodeA=new LinkNode();
            LinkNode linkNodeB=new LinkNode();
            //给出两个单调递增数组
            int []A=new int[]{1,2,3,4,5,6,8,10};
            int []B=new int[]{2,5,8,10,11};
    
            for(int i=0;i<A.length;i++)
                linkNodeA.insertList(A[i]);
            for(int j=0;j<B.length;j++)
                linkNodeB.insertList(B[j]);
    
            LinkNode.ANode headA=linkNodeA.getHead();
            LinkNode.ANode headB=linkNodeB.getHead();
    
            LinkNode.ANode p=null,q=null,r=null,temp=null;
            //处理第一个节点
            temp=headB;
            while(true){
                if(headA.data==temp.data){
                    headA=headA.next;
                    temp=temp.next;
                }
                 else if(headA.data>temp.data)
                    temp=headB.next;
                else
                    break;
            }
            r=headA;
            p=headA;
            q=headB;
            while(p!=null&&q!=null){
                if(p.data==q.data){
                    r.next=p.next;//删除操作
                    p=r.next;
                }
                else if(p.data>q.data)
                    q=q.next;
                else{
                    r=p;
                    p=p.next;
                }
            }
            LinkNode.ANode temp1=headA;
            while(temp1!=null){
                System.out.println(temp1.data);
                temp1=temp1.next;
            }
        }
    }
    


    展开全文
  • 154个元素组成有序表进行二分法查找,可能的比较次数为() A:10 B:8 C:4 D:2答案:BCD别出新意的解题思路: 折半查找过程可用二叉树来描述,把有序表中间位置上的结点作为树的根结点,左子表和右子表...

    在154个元素组成有序表进行二分法查找,可能的比较次数为()
    A:10
    B:8
    C:4
    D:2

    答案:BCD

    别出新意的解题思路:

    折半查找过程可用二叉树来描述,把有序表中间位置上的结点作为树的根结点,左子表和右子表分别对应树的左子树和右子树。折半查找的过程就是走一条从根节点到被查结点的一条路径,比较的次数就是该路径中结点的个数,即,该结点在树中的层数。 所以该题可以转换为求有154个结点的二叉树有几层,小于等于这个层数的数值就是答案。 又知,深度为K的二叉树最多有2的K次方-1个结点,深度为7的二叉树最多有127个结点,深度为8的二叉树最多有255个结点,所以154个结点的二叉树有8层。

    代码实现:

    int TestBinSearch(int first, int end)
    {
        if(first < end)
        {
            int mid = (first + end) / 2;
            int numOfLeftCmp = TestBinSearch(first, mid - 1);
            int numOfRightCmp = TestBinSearch(mid + 1, end);
            if(numOfLeftCmp > numOfRightCmp)
                return numOfLeftCmp + 1;
            else
                return numOfRightCmp + 1;
        }
        else if(first == end)
            return 1;
        else
            return 0;
    }
    int main()
    {
        cout << TestBinSearch(0, 153) << endl;
    }

    运行结果:
    8

    展开全文
  • 刚开始学数据结构,还费了很多的时间才做完这实验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;
    } 
    

     

    展开全文
  • 154个元素组成有序表进行二分法查找,可能的比较次数为 正确答案: B C D 你的答案: B (错误) 10 8 4 1 添加笔记 求解答(6) 收藏 纠错 折半查找过程可用二叉树...
  •  写一个函数SortedMerge函数,该函数有两个参数,都是递增的链表,函数的功能就是合并这两个递增的链表为一个递增的链表,SortedMerge的返回值是新的链表。新链表由前两个链表按元素递增顺序合并而成,也就是说它...
  • 直接上代码 ...#define LIST_INIT_SIZE 10//顺序存储空间的初始分配量 #define LISTINCREMENT 5// 顺序存储空间的分配增量 #define OVERFLOW 0 #define ok 1 typedef struct{ int *element;//...
  • 一个有序顺序表中删除重复的元素并返回新的长,要求空间复杂度为O(1); */ # include typedef int ElemType; typedef struct { ElemType data[100]; int length; }SqList; int removeSame1(SqList &B) { ...
  • 假设有两元素值递增有序排列的线性表a和b,均以单链表作为存储结构,请编程实现将a和b归并成一元素值递减有序排列的线性表c(注意:非严格递减,也就是说本题的数据有可能相等),并要求利用原的...
  • 已知顺序表中元素元素值非递减有序排列,编写一个算法,删除顺序表中多余的值相同的元素。 运行截图: 代码: #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR -1 #define ...
  • 实验目的 熟悉将算法转换成程序代码的过程,了解...(1)非递减有序的顺序表中插入一个元素x,保持顺序表有序性               #include&lt;stdio.h&gt; #include&lt;stdlib.h&g...
  •  写一个函数SortedMerge函数,该函数有两个参数,都是递增的链表,函数的功能就是合并这两个递增的链表为一个递增的链表,SortedMerge的返回值是新的链表。新链表由前两个链表按元素递增顺序合并而成,也就是说它...
  • 已知线性表中元素以值递增有序排列,并以单链表作为存储结构 设计一个算法,删除中值相同的多余元素 使得操作后表中所用元素值均不同,同时释放被删除的结点空间
  • A和B是两个单链表(带有表头节点),其中元素是递增有序的,设计一个算法,将A和B归并成一个按元素值非增减有序的链表C,C由链表A和B的节点组成 2. 思路分析: ① 我们知道头插法最终创建的链表的顺序与插入的顺序...
  • 实现一个函数,把两个从大到小的有序链表合并成一个链表,新的链表是一个从小到大的有序链表。这道题可以分成两个思路: 1.先把两个链表合并成一个链表,合并后的链表从大到小排序 2.将链表逆置,得到从小到达排序...
  • 例如需要查找有序list里面的某个关键字key的位置,那么首先确认list的位数mid,下面分为三种情况: 如果 list[mid] < key,说明key 在中位数的 右边; 如果 list[mid]> key,说明key 在中位数的 左边; ...
  • 算法思想:因为是顺序表,用类似于直接插入排序的思想,将第一个元素看作非重复的有序表,之后依序判断后面的元素是否和前面非重复的有序表中的最后一个元素相同,相同则舍弃,不同则加入有序表,直至判断到表尾。...
  • 给你一个矩阵 mat,其中每一行的元素都已经按 递增 顺序排好了。 请你帮忙找出所有这些行 最小的公共元素。 如果矩阵没有这样的公共元素,就请返回 -1。 示例: 输入:mat = [[1,2,3,4,5],[2,4,5,8,10],[3,5,7...
  • 将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据。 #include #include typedef struct list { int data; ...
  • 创建一个有序链表

    千次阅读 2014-05-19 17:12:21
    #include using namespace std; struct Node//节点结构体 { int n; Node *next;...//有序插入节点函数 void Show(Node *H);//输出链表 int main(int argc, char const *argv[]) { int n; Node *
  • 顺序表中第五个位置插入一个元素9,实现顺序插入的基本操作,输出顺序表中所有元素 #include&lt;iostream&gt; using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef...
  • 已知两非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的...在一输出合并后新的非降序链表,要求链表没有重复元素。数字间用空格分开,结尾不能有多余空格;若新链表为空,输出NULL。 输入样例: 这...
  • 非递减有序表合并

    千次阅读 2016-11-20 12:15:42
    设计实现一个算法,用以对两个非递减有序表A、B进行合并,其中A=(2,5,8,9) ,B=(3,4,8,10,12,20)。 对两个表依次查找,例如以A表为主要目标,从B表依次查找,因为两个表都是有序的,所以从B的第一个...
  • 顺序有序顺序重复元素删除

    千次阅读 2020-06-16 21:12:37
    (2.2.4-6)从有序顺序表中删除所有其值重复的元素,使表中所有元素的值均不同。 不考虑时间复杂度,空间复杂度为o(1) 思路:例SqList L = { 1, 2, 2, 3, 4, 4 },将每一个元素与之后面的元素进行比较,1与2比较...
  • 创建一个有序的链表

    千次阅读 2014-06-05 22:50:04
    创建有序链表的基本思路就是插入一个新节点之前,先按有序查找到新节点应该插入的位置,然后再插入! //代码实现环境:windows 7 32bit + MinGW + Sublime Text 3 #include <iostream> using ...
  • PTA—— 两个有序链表序列的交集

    千次阅读 2019-05-08 21:39:06
    PTA—— 两个有序链表序列的交集C] 题目: 已知两非降序链表序列S1与S2,设计函数...在一输出两输入序列的交集序列,数字间用空格分开,结尾不能有多余空格;若新链表为空,输出NULL。 输入样例: 1 2 5 -...
  • 有序表的顺序查找分析

    千次阅读 多人点赞 2016-10-24 15:41:24
    一般线性表的顺序查找,有序表的二分查找,基于索引的分块查找等都是有独特特征的查找方式,但是有种查找夹一般线性表和有序下的二分查找中间,很容易被忽视,因此提出来单独讨论。这查找就是:有序表的顺序...
  • 为了提高查找效率,对65025个元素有序顺序建立索引顺序结构,最好情况下查找到表中已有元素,平均需要执行(B)次关键字比较。 A. 10 B. 14 C. 20 D. 21 分析:明确一个概念:索引顺序结构就是分块...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 131,033
精华内容 52,413
关键字:

在一个10元素的有序表中