精华内容
下载资源
问答
  • 精品文档 第二章 线性表 一名 解 1. 性 构 2. 数据 构的 序 3. 序表 4. 表 5. 数据 构的 接 6. 建表 7. 字符串 8. 串 9. 序串 10. 串 二填空 1. 了便于 有 将含 n(n>=0) 个 点的 性 构表示成 (a a, ? a) 其中每 n12 ...
  • 关于数据结构的绪论和线性表练习题,希望对大家有帮助。15.分析:首先在链表中查找元素值为X的结点,若找到则让freq域的值增1;然后 依次和它的前趋的freq域值比较,若比前freq域值大,和前趋结点位置交换,直到...
  • 数据结构
  • 数据结构 线性表 练习题 试卷及答案.doc
  • 三写一个算法合并两个已排序的线性表用两种方法数组表示的线性表顺序表和指针表示的线性表链表 要求1定义线性表节点的结构并定义节点的型和位置的型 2定义线性表的基本操作 3在12的基础上完成本 4在main函数中进行...
  • pta 数据结构 线性表习题

    千次阅读 多人点赞 2020-11-19 16:22:55
    学习使我快乐判断选择函数 判断 1-1 对于顺序存储的长度为N的线性表,访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。 T F 1-2 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入...

    学习使我快乐

    判断题

    1-1 对于顺序存储的长度为N的线性表,访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。

    • T
    • F

    1-2 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算,则利用顺序表存储最节省时间。

    • T
    • F

    1-3 对于顺序存储的长度为N的线性表,删除第一个元素和插入最后一个元素的时间复杂度分别对应为O(1)和O(N)。

    • T

    • F

    1-4 若用链表来表示一个线性表,则表中元素的地址一定是连续的。

    • T

    • F

    选择题

    2-1 在N个结点的顺序表中,算法的时间复杂度为O(1)的操作是:

    A. 访问第i个结点(1≤i≤N)和求第i个结点的直接前驱(2≤i≤N)

    B. 在第i个结点后插入一个新结点(1≤i≤N)

    C. 删除第i个结点(1≤i≤N)

    D. 将N个结点从小到大排序

    2-2 对于顺序存储的长度为N的线性表,访问结点和增加结点的时间复杂度为:
    A. O(1), O(1)

    B. O(1), O(N)

    C. O(N), O(1)

    D. O(N), O(N)

    2-3 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算,则利用哪种存储方式最节省时间?
    A. 双链表

    B. 单循环链表

    C. 带头结点的双循环链表

    D. 顺序表

    2-4 顺序表中第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是( )。

    A. 100

    B. 105

    C. 108

    D. 110

    2-5 下列函数中,哪两个函数具有相同的增长速度:

    A. 2N和N​N

    B. N和2/N

    C. N​2logN和NlogN​2

    D. NlogN​2和NlogN

    2-6 算法的时间复杂度取决于( )。

    A. 问题的规模

    B. 待处理数据的初态

    C. 计算机的配置

    D. A和B

    2-7 已知两个长度分别为m和n的升序链表,若将它们合并为一个长度为m+n的降序链表,则最坏情况下的时间复杂度是( )。

    A. O(n)

    B. O(mn)

    C. O(min(m,n))

    D. O(max(m,n))

    2-8 下列代码的时间复杂度是:

    for(i=0; i<N; i++)
        for(j=0; j<N; j+=1000)
            printf("%d,%d\n", i, j);
    

    A. O(N×j)

    B. O(N)

    C. O(N2)

    D. O(NlogN)

    2-9 下面程序段的时间复杂度是 ( )

    i = 0while(i<=n)
         i = i * 3

    A. O(2n)

    B. O(n)

    C. O(n​2)

    D. O(log​3n)

    2-10 程序段

    FOR  i:=n-1  DOWNTO  1  DO
                FOR j:=1 TO i DO
                   IF A[j]>A[j+1]
                      THEN  A[j]与A[j+1]对换;
    

    其中 n为正整数,则最后一行的语句频度在最坏情况下是( )

    A. O(n)

    B. O(nlogn)

    C. O(n3)

    D.O(n​2)

    2-11 下列叙述中正确的是

    A. 程序执行的效率与数据的存储结构密切相关

    B. 程序执行的效率只取决于程序的控制结构

    C. 程序执行的效率只取决于所处理的数据量

    D. 以上说法均错误

    函数题

    6-2 多项式求值
    本题要求实现一个函数,计算阶数为n,系数为a[0] … a[n]的多项式f(x)=∑ ni=0(a[i] × xi) 在x点的值。

    函数接口定义:

    double f( int n, double a[], double x );
    

    其中n是多项式的阶数,a[]中存储系数,x是给定点。函数须返回多项式f(x)的值。

    裁判测试程序样例:

    #include <stdio.h>
    #define MAXN 10
    double f( int n, double a[], double x );
    int main()
    {
        int n, i;
        double a[MAXN], x;
        scanf("%d %lf", &n, &x);
        for ( i=0; i<=n; i++ )
            scanf(%lf”, &a[i]);
        printf("%.1f\n", f(n, a, x));
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */
    

    输入样例:

    2 1.1
    1 2.5 -38.7
    

    输出样例:

    -43.1
    

    代码:

    double f( int n, double a[], double x ){
        double ans;
        for (int i = 0; i <= n; ++i) {
            ans+=a[i]*pow(x,i);
        }
        return ans;
    }
    

    **6-3 使用函数判断完全平方数 **
    本题要求实现一个判断整数是否为完全平方数的简单函数。

    函数接口定义:

    int IsSquare( int n );
    

    其中n是用户传入的参数,在长整型范围内。如果n是完全平方数,则函数IsSquare必须返回1,否则返回0。

    裁判测试程序样例:

    #include <stdio.h>
    #include <math.h>
    
    int IsSquare( int n );
    
    int main()
    {
        int n;
        scanf("%d", &n);
        if ( IsSquare(n) ) printf("YES\n");
        else printf("NO\n");
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */
    

    输入样例1:

    10
    

    输出样例1:

    NO
    

    输入样例2:

    100
    

    输出样例2:

    YES
    

    代码

    int IsSquare( int n )
    {
        int h =pow(n,0.5);
        if(pow(h,2)==n)return 1;
        return 0;
    }
    
    展开全文
  • 数据结构 主讲人:米晓红 hongxiaomi@163.com 器EE 线性表习题课 要点回顾 1线性表的逻辑特征 令1在非空的线性表,有且仅有一个开始结点a1,它没 有直接前趋,而仅有一个直接后继a2 令2)有且仅有一个终端结点an,它没有...
  • 数 据 结 构 计算机科学与技术学院 Page 2 2020-3-4 线性数据结构部分综合练习 若某线性表采用顺序存储结构每个元素占四个存储单元首地址为100则下标为11的(第12个)元素的存储地址为 线性表的链式存储结构主要包括 ...
  • 7-2 两个有序链表序列的合并 (20 分) 已知两个非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的非降序链表S3。 输入格式: 输入分两行,分别在每行给出由若干个正整数构成的非降序序列,用−1表示序列的结尾...

    7-2 两个有序链表序列的合并 (20 分)

    已知两个非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的非降序链表S3。
    输入格式:
    输入分两行,分别在每行给出由若干个正整数构成的非降序序列,用−1表示序列的结尾(−1不属于这个序列)。数字用空格间隔。
    输出格式:
    在一行中输出合并后新的非降序链表,数字间用空格分开,结尾不能有多余空格;若新链表为空,输出NULL。
    输入样例:
    1 3 5 -1
    2 4 6 8 10 -1
    输出样例:
    1 2 3 4 5 6 8 10
    c++

    #include <iostream>
    using namespace std;
    
    const int maxn = 10000;
    int A[maxn];
    int B[maxn];
    void Merg(int A[],int B[],int beg,int end)
    {
        int i= 0;
        int j= 0;
        int k= 0;
        int c[maxn];
        while (i<beg&&j<end)
        {
            if(A[i]<B[j])
                c[k++] = A[i++];
            else
                c[k++] = B[j++];
        }
        while (i<beg) c[k++] = A[i++];
        while (j<end) c[k++] = B[j++];
        for (int t = 0,i=0; t <k ; ++t) {
            A[t] = c[i++];
        }
    }
    int main()
    {
        int i=0;
        int j=0;
        int n,m;
        cin>>n;
        while(n!=-1)
        {
            A[i] = n;
            cin>>n;
            i+=1;
        }
        cin>>m;
        while(m!=-1)
        {
            B[j] = m;
            cin>>m;
            j+=1;
        }
        Merg(A,B,i,j);
        for(int k=0; k<i+j; k++)
            cout<<A[k]<<" ";
    }
    

    7-3 回文判断 (20 分)

    回文是指正读反读均相同的字符序列,如“abba”和“abdba”均是回文,但“good”不是回文。编写一个程序,使用栈判定给定的字符序列是否为回文。
    输入格式:
    输入待判断的字符序列,按回车键结束,字符序列长度<20。
    输出格式:
    若字符序列是回文,输出“YES”;否则,输出“NO”。
    输入样例:
    abdba
    输出样例:
    YES
    算法分析:
    该题目仅需要:栈的入栈和出栈操作,便于实现

    #include <iostream>
    using namespace std;
    const int maxn= 20+5;
    char str[maxn];
    struct Stack{
        char elem[maxn];
        int top;
    }s;
    void push(char c)
    {
        s.elem[++s.top] = c;   
    }
    char pop()
    {
        return s.elem[s.top--];
    }
    int main()
    {
        char c;
        int j=0;
        while((c=getchar())!='\n')
        {
            str[j] = c;
            push(c);
            j++;
        }
        int flag = 0;
        for (int i = 0; i <j ; ++i) {
            if(str[i]==pop())
                continue;
            else
            {
                flag = 1;
                break;
            }
        }
        if(flag == 1)
            cout<<"NO";
        else
            cout<<"YES";
    }
    
    展开全文
  • 数据结构线性表习题

    2013-12-23 09:12:52
    这是数据结构中,最基础,也是入门的时候最重要的一章,线性表习题
  • 数据结构的顺序实现 3.顺序表 4.链表 5.数据结构的链接实现 6. 建表 7.字符串 8.串 9.顺序串 10.链串 二填空 1.为了便于讨论有时将含n(n>=0)个结点的线性结构表示成(aa,a)其中每个n12a代表一个_a称为_结点a称为_...
  • 今天给大家介绍几道常考的关于数据结构线性表习题。小小拙见,希望对你有帮助哦! 一、移除链表元素 问题描述 删除链表中等于给定值 val 的所有节点。 示例: 输入: 1->2->6->3->4->5->6, val = ...

    今天给大家介绍几道常考的关于数据结构线性表的习题。小小拙见,希望对你有帮助哦!

    一、移除链表元素

    问题描述

    删除链表中等于给定值 val 的所有节点。
    示例:
    输入: 1->2->6->3->4->5->6, val = 6
    输出: 1->2->3->4->5

    思路

    分析
    这道题是关于单链表的操作,这道题比较简单。要删除链表中等于给定值 val 的所有节点,首先应该找到为val 的节点,然后将此节点删除即可。
    需要注意的是题目要求为删除等于给定值 val 的所有节点,所以我们需要遍历链表,遇到等于val 的节点,将其删除,直到将整个链表遍历一遍此操作结束。
    思路有了之后我们就开始上手写代码,具体代码如下。

    代码

    #include"list.h"
    void RemoveAll(SList *plist, int val)
    {
    	assert(plist != NULL);
    	SListNode *p = plist->head;
    	SListNode *prev = NULL;
    	if (p== NULL)
    		return;
    	while (p != NULL)
    	{
    		if (p->data == val)
    		{
    			SListNode *next = p->next;   //保存p->next
    			//第一个节点值为val
    			if (prev == NULL)
    				plist->head = p->next;
    			else
    				prev->next = p->next;
    			free(p);
    			p = next;
    		}
    		else
    		{
    			prev = p;
    			p = p->next;
    		}
    	}
    	return;
    }
    

    测试

    void main()
    {
    	SList p;
    	SListInit(&p);
    	SListPushFront(&p, 1);
    	SListPushFront(&p, 2);
    	SListPushFront(&p, 3);
    	SListPushFront(&p, 6);
    	SListPushFront(&p, 4);
    	SListPushFront(&p, 5);
    	SListPushFront(&p, 6);
    	SListShow(&p);
    	RemoveAll(&p, 6);
    	SListShow(&p);
    
    }
    

    测试结果
    在这里插入图片描述
    说明:首先调用头插将元素1、2、3、6、4、5、6插入链表p,在调用RemoveAll函数删除链表中所有值为6的节点。删除后的链表为5->4->3->2->1。
    链表结构体定义、初始化、头插等操作在前面也有讲解哦!在这里只负责调用哦!
    附上链接
    数据结构——线性表(顺序表、链表)

    二、取单链表中间值(带头结点)

    问题描述

    给定一个带有头结点 head 的非空单链表,返回链表的中间结点。
    如果有两个中间结点,则返回第二个中间结点。

    思路

    分析:这道题也是单链表的操作,通过遍历单链表找出中间结点。最后返回中间结点。
    思路:采用两个快慢指针,一起从头结点的后继开始遍历单链表,慢指针走一步相应的快指针走两步,当快指针为NULL的时候慢指针所指的结点就为中间结点。假设一个单链表有n+1个结点(含头结点),则慢指针遍历过的结点数为n/2(n为偶数)或者(n+1)/2,快指针遍历过的结点数为n。

    代码

    #include"list.h"
    SListNode* middleNode(SList *st)
    {
    	SListNode *fast, *slow;
    	if (st->head == NULL || st->head->next == NULL)
    		return NULL;
    	fast = slow = st->head->next;
    	while (fast&&fast->next != NULL)
    	{
    		fast = fast->next->next;
    		slow = slow->next;
    	}
    	return slow->data;
    }
    

    测试

    void main()
    {
    	SList p;
    	SListInit(&p);
    	SListPushFront(&p, 1);
    	SListPushFront(&p, 2);
    	SListPushFront(&p, 3);
    	SListPushFront(&p, 6);
    	SListPushFront(&p, 4);
    	SListPushFront(&p, 5);
    	SListPushFront(&p, 7);
    	SListShow(&p);
    	printf("%d\n", middleNode(&p));
    
    }
    

    测试结果
    在这里插入图片描述
    说明:首先调用头插将元素1、2、3、6、4、5、7插入链表p,此时链表为7->5->4->6->3->2->1->head,然后调用middleNode函数找出中间结点是值为3的结点。插入元素结束后链表加上头结点一共有8个结点,此时的中间结点为6和3,根据题目要求结点个数为偶数时返回后面结点,所以返回3。

    三、取链表中倒数第k个结点

    问题描述

    给定一个非空单链表,返回链表倒数第k个结点。

    思路

    分析:思路与取中间中间类似。
    思路:采用两个快慢指针,一起从头结点开始遍历单链表,快指针走k步之后慢指针再开始走,当快指针为NULL的时候慢指针所指的结点就为倒数第k个结点。

    代码

    #include"list.h"
    
    SListNode* Remove(SList *pst, int key)
    {
    	SListNode *fast, *slow;
    	if (pst->head == NULL)
    		return NULL;
    	fast = slow = pst->head;
    	while (key-- > 0)
    	{
    		if (fast == NULL)
    			return NULL;
    		fast = fast->next;
    	}
    	while (fast != NULL)
    	{
    		fast = fast->next;
    		slow = slow->next;
    	}
    	return slow->data;
    }
    

    测试

    void main()
    {
    	SList p;
    	SListInit(&p);
    	SListPushFront(&p, 1);
    	SListPushFront(&p, 2);
    	SListPushFront(&p, 3);
    	SListPushFront(&p, 6);
    	SListPushFront(&p, 4);
    	SListPushFront(&p, 5);
    	SListPushFront(&p, 6);
    	SListShow(&p);
    	printf("%d\n", Remove(&p, 3));
    }
    

    测试结果
    在这里插入图片描述
    说明:调用头插法插入元素之后链表为:6->5->4->6->3->2->1,取倒数第4个结点为6。

    四、括号匹配问题

    问题描述

    给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效。
    有效字符串需满足:
    左括号必须用相同类型的右括号闭合。
    左括号必须以正确的顺序闭合。

    思路

    分析:本题只考虑6个括号字符串,不考虑其他字符串与括号匹配的问题。选择用栈来判断括号,在字符串不为空的情况下先将左括号入栈。如果右括号与栈顶左括号匹配则栈顶左括号出栈,同理判断若栈为空且字符串为空则括号匹配,否则不匹配。
    思路:字符串出现的情况分为有研究价值和无研究价值两种。
    其中无研究价值
    (1)、字符串为"\0"
    (2)、字符串为空字符串
    有研究价值:字符串不为空也不为"\0".
    (1)、括号数:左括号=右括号。存在匹配与不匹配两种情况。
    (2)、括号数:左括号!=右括号。此种情况括号不匹配。
    在左括号!=右括号时要考虑两种特殊情况:
    (1)、全为左括号:字符串为空,栈不为空,括号不匹配。
    (2)、全为右括号:栈为空,字符串不为空,括号不匹配。

    代码

    #include"stack.h"
    //括号匹配问题
    bool isValid(char *s)
    {
    	LinkStack st;
    	if (s == NULL)
    		return false;
    	if (*s == '\0')
    		return true;
    	LinkStackInit(&st);
    	while (*s != '\0')
    	{
    		if (*s == '{' || *s == '[' || *s == '(')
    			LinkStackPush(&st, *s);
    		else
    		{
    			//防止左括号多于右括号的情况!
    			if (LinkStackEmpty(&st))
    				printf("字符串不匹配,括号不合法!\n");
    				
    			char top = LinkStackTop(&st);
    			if ((*s == '}'&&top != '{') || (*s == ']'&&top != '[') || (*s == ')'&&top != '('))
    				printf("字符串不匹配,括号不合法!\n");
    	
    			LinkStackPop(&st);
    		}
    		s++;
    	}
    	if (LinkStackEmpty(&st))
    		printf("字符串匹配,括号合法!\n");
    	else
    		printf("字符串不匹配,括号不合法!\n");
    	LinkStackDestory(&st);
    	return 0;
    }
    

    测试

    int main()
    {
    	char *s1="{[()]}";   //匹配
    	char *s2 = "{[()}";  //左括号多于右括号
    	char *s3 = "[]}";    //右括号多于左括号
    	char *s4 = "{[(";    //只有左括号
    	char *s5 = ")]}";    //只有右括号
    	isValid(s1);
    	isValid(s2);
    	isValid(s3);
    	isValid(s4);
    	isValid(s5);
    
    	return 0;
    }
    

    测试结果
    在这里插入图片描述

    说明
    (1)、字符串为"{[()]}“时,左括号数=右括号数,此时字符串匹配,括号合法。
    (2)、字符串为”{[()]“时,左括号数>右括号数,此时字符串不匹配,括号不合法。
    (3)、字符串为”[]}“时,左括号数<右括号数,此时字符串不匹配,括号不合法。
    (4)、字符串为”{[(“时,只有左括号,此时栈不为空,括号不合法。
    (5)、字符串为”)]}"时,只有右括号,此时字符串不为空,括号不合法。
    链表结构体定义、初始化、头插等操作在前面也有讲解哦!在这里只负责调用哦!
    附上链接
    数据结构——线性表(顺序表、链表)

    五、栈实现队列

    问题描述

    用栈实现创建队列、入队、出队、取队头元素、判空、释放。

    思路

    分析:借用两个栈结构,一个用于入队,一个用于出队。
    思路:两个栈分别为栈1和栈2,栈1用于入队,栈2用于出队。当入队时,依次入栈1(此时栈顶元素为队尾元素)。出队时,将栈1中的栈顶元素出栈1并入栈到栈2,当栈1为空时栈2的栈顶元素为队列的队头元素,此时出队操作即为栈2出栈,当栈2为空时队列元素全部出队。队列的判空操作即判断栈1和栈2是否为空,若全为空则队列为空,若有一个不为空则队列不为空。

    代码

    #include"stack.h"
    
    typedef struct
    {
    	LinkStack instack;
    	LinkStack outstack;
    }MyQueue;
    
    //创建队列
    MyQueue* myQueueCreate()
    {
    	MyQueue *pq = (MyQueue*)malloc(sizeof(MyQueue));
    	LinkStackInit(&(pq->instack));
    	LinkStackInit(&(pq->outstack));
    	return pq;
    }
    
    //入队
    void myQueuePush(MyQueue *pq, int x)
    {
    	LinkStackPush(&(pq->instack), x);
    }
    
    //出队
    int myQueuePop(MyQueue *pq)
    {
    	if (LinkStackEmpty(&(pq->outstack)))
    	{
    		while (!LinkStackEmpty(&(pq->instack)))
    		{
    			LinkStackPush(&(pq->outstack), LinkStackTop(&(pq->instack)));
    			LinkStackPop(&(pq->instack));
    		}
    	}
    	ElemType val = LinkStackTop(&(pq->outstack));
    	LinkStackPop(&(pq->outstack));
    	return val;
    }
    
    //取队头元素
    int myQueueFront(MyQueue *pq)
    {
    	if (LinkStackEmpty(&(pq->outstack)))
    	{
    		while (!LinkStackEmpty(&(pq->instack)))
    		{
    			LinkStackPush(&(pq->outstack), LinkStackTop(&(pq->instack)));
    			LinkStackPop(&(pq->instack));
    		}
    	}
    	ElemType val = LinkStackTop(&(pq->outstack));
    	return val;
    }
    
    //判空
    bool myQueueEmpty(MyQueue *pq)
    {
    	return LinkStackEmpty(&(pq->instack)) && LinkStackEmpty(&(pq->outstack));
    }
    
    //释放
    void myQueueFree(MyQueue *pq)
    {
    	LinkStackDestory(&(pq->instack));
    	LinkStackDestory(&(pq->outstack));
    	free(pq);
    }
    
    

    栈结构体定义、初始化、入栈、出栈等操作在前面也有讲解哦!在这里只负责调用哦!
    附上链接
    数据结构——线性表(栈)

    六、最小栈

    问题描述

    设计一个支持入栈、出栈、取栈顶元素的操作,并且能在常数时间内检索到最小元素的栈

    思路

    分析:借用两个栈结构,一个栈用于正常入栈、出栈、取栈顶元素的操作,另一个栈用于存放最小元素。
    思路:最小栈与普通栈最本质的区别在于可以在下常数时间内取栈内的最小元素,要想实现这一功能我们只需要在原来栈(st)的结构基础上再增加一个栈结构(min_st),用来保存每次入栈(st)后st中的最小元素。

    代码

    #include"stack.h"
    
    typedef struct
    {
    	LinkStack st;
    	LinkStack min_st;
    }MinStack;
    //创建最小栈
    MinStack* minStackCreate()
    {
    	MinStack *pmst = (MinStack*)malloc(sizeof(MinStack));
    	LinkStackInit(&(pmst->st));
    	LinkStackInit(&(pmst->min_st));
    	return pmst;
    }
    //入栈
    void minStackPush(MinStack *pmst, int x)
    {
    	LinkStackPush(&(pmst->st), x);
    	if (LinkStackEmpty(&(pmst->min_st)) && x <= LinkStackTop(&(pmst->min_st)))
    		LinkStackPush(&(pmst->min_st), x);
    }
    //出栈
    void minStackPop(MinStack *pmst)
    {
    	ElemType topval = LinkStackTop(&(pmst->st));
    	LinkStackPop(&(pmst->st));
    	if (topval < LinkStackTop(&(pmst->min_st)))
    		LinkStackPop(&(pmst->min_st));
    }
    //取栈顶元素
    int minStackTop(MinStack *pmst)
    {
    	return LinkStackTop(&(pmst->st));
    }
    //取最小元素
    int minStackGetMin(MinStack *pmst)
    {
    	return LinkStackTop(&(pmst->min_st));
    }
    
    
    //释放
    void minStackFree(MinStack *pmst)
    {
    	LinkStackDestory(&(pmst->st));
    	LinkStackDestory(&(pmst->min_st));
    	free(pmst);
    }
    

    七、队列实现栈

    问题描述

    用队列实现创建栈、入栈、出栈、取栈顶元素、判空、释放。

    思路

    分析:借用两个队列结构,实现栈。
    思路:栈结构的特点是先进后出,为了满足这一特性再用队列实现栈时需要两个队列结构。
    入栈操作:选择一个空队列进行入栈,假设入栈的队列为L1,另一个队列为L2,此时L1的队尾元素为栈顶元素;
    出栈操作:将队列L1中的元素依次出队,再入队到L2,此时队列L2的队头元素为栈顶元素(取栈顶元素取L2队头元素即可),L2依次出队即可完成出栈操作;
    判空:判断队列L1,L2均为空即栈为空。

    代码

    #include"queue.h"
    
    typedef struct
    {
    	LinkQueue q1;
    	LinkQueue q2;
    }MyStack;
    
    //创建栈
    MyStack* myStackCreate()
    {
    	MyStack *pst = (MyStack*)malloc(sizeof(MyStack));
    	LinkQueueInit(&(pst->q1));
    	LinkQueueInit(&(pst->q2));
    	return pst;
    }
    //入栈
    void myStackPush(MyStack *pst, int x)
    {
    	LinkQueue *pnoempty;
    	if (LinkQueueEmpty(&(pst->q1)))
    		pnoempty = &(pst->q2);
    	else
    		pnoempty = &(pst->q1);
    	LinkQueueEnQue(pnoempty, x);
    }
    //出栈
    int myStackPop(MyStack *pst)
    {
    	LinkQueue *pempty, *pnoempty;
    	if (LinkQueueEmpty(&(pst->q1)))
    	{
    		pempty = &(pst->q1);
    		pnoempty = &(pst->q2);
    	}
    	else
    	{
    		pempty = &(pst->q2);
    		pnoempty = &(pst->q1);
    	}
    	ElemType val;
    	while (!LinkQueueEmpty(pnoempty))
    	{
    		val = LinkQueueFront(pnoempty);
    		LinkQueueDeQue(pnoempty);
    		if (LinkQueueEmpty(pnoempty))
    			break;
    		LinkQueueEnQue(pempty, val);
    	}
    	return val;
    }
    
    //获取栈顶元素
    int myStackTop(MyStack *pst)
    {
    	LinkQueue *pnoempty;
    	if (LinkQueueEmpty(&(pst->q1)))
    		pnoempty = &(pst->q2);
    	else
    		pnoempty = &(pst->q1);
    	return LinkQueueBack(pnoempty);
    
    }
    //判空
    bool myStackEmpty(MyStack *pst)
    {
    	return LinkQueueEmpty(&(pst->q1)) && LinkQueueEmpty(&(pst->q2));
    }
    //释放栈
    void myStackFree(MyStack *pst)
    {
    	LinkQueueDestory(&(pst->q1));
    	LinkQueueDestory(&(pst->q2));
    	free(pst);
    }
    

    队列结构体定义、初始化、入队、出队等操作在前面也有讲解哦!在这里只负责调用哦!
    附上链接
    数据结构——线性表(队列)

    以上就是关于队列的所有知识啦!
    希望这些知识对你有用哦!
    感谢浏览!阿里嘎都
    如果能点赞的话那就更好啦!

    在这里插入图片描述

    展开全文
  • 这次博客做一个练习题,是我们学校的C++练习题,题目如下: 问题描述: 1)实现链表的排序(升序) 2)实现两个有序链表的合并:A=A∪B,要求合并后仍然有序。 提交前请将所有的提示信息去掉,只保留最后的输出...

     最近好忙,好长时间都没更新博客,唉,罪过罪过。

     这次博客做一个练习题,是我们学校的C++练习题,题目如下:

    问题描述:

    1)实现链表的排序(升序)

    2)实现两个有序链表的合并:A=A∪B,要求合并后仍然有序。

    提交前请将所有的提示信息去掉,只保留最后的输出结果。例如运行时:从键盘直接输入:

    2 1 2
    3 1 2 3 

    输出结果为:

    1
    2
    3

           分别表示第一个链表元素个数为2,元素分别为 1,2 ;第二个链表元素个数为3,元素分别为1,2,3。

           这个题比较简单,我用链表做的,有很多人说链表难,我觉得只要你弄懂了没有什么是难的。

           链表需要一个链表类和一个节点类,链表由一个一个节点组成,每个节点的地址由系统随机生成,需要一个就加一个,节点的成员变量包括data(需要节点存储的数据)和link(下一个节点的头地址),这是单链表节点的特点,至于双链表各位朋友可以上网搜索,双链表和单链表的思想是一样的,只不过双链表多了一个头指针,用来指向上一个节点的地址。

           这个题目比较简单,下面直接给出求解这个问题的完整代码:

    #include <iostream>
    #include <stdlib.h>
    using namespace std;
    class List;
    class LinkNode{//链表节点类
        friend List;//定义List为友元类
    public:
        LinkNode *link;//用来存储下一个节点的地址
        int data;//需要节点存储的数据
    public:
        LinkNode(const int & item,LinkNode *ptr=NULL){data=item;link=ptr;}//构造函数赋初值
        LinkNode(LinkNode *ptr=NULL){link=ptr;}//函数重载
        ~LinkNode(){};//析构函数,释放节点内存
    };
    
    class List{//链表类
    public:
        LinkNode *first;//头指针
        int da[1000]={0};
    public:
        List(){first = new LinkNode();}
        ~List(){MakeEmpty();}//析构函数,释放链表内存
        void MakeEmpty();
        void input(int node_number);
        void Sort();
        void output();
    };
    
    void List::MakeEmpty(){
        LinkNode *q;
        while(first->link!=NULL){
            q= first->link;
            first->link = q->link;
            delete q;
        }
    }
    
    void List::input(int node_number){
        LinkNode *newnode;
        int val;
        for (int i=0;i<node_number;i++){
            cin>>val;
            da[i] = val;
            newnode = new LinkNode(val);
            newnode->link = first->link;
            first->link = newnode;
        }
    }
    
    void List::output(){
        LinkNode *q;
        q = first;
        while(q->link!=NULL){
            q = q->link;
            q->link = q->link;
            cout<<q->data<<endl;
        }
        cout<<endl;
    }
    
    void List::Sort(){
        for(int i=0;da[i]!=0;i++){
            for(int j=i+1;da[j]!=0;j++){
                if(da[j]<da[i]){
                    int temp = da[i];
                    da[i] = da[j];
                    da[j] = temp;
                }
            }
        }
    }
    int main()
    {
        List a,b;
        int x,y,i,j;
        int symbol=0;
        cin>>x;//链表节点个数
        a.input(x);
        a.Sort();
        cin>>y;
        b.input(y);
        b.Sort();
        for(i=0;a.da[i]!=0;i++){
                symbol = 0;
            for(j=0;b.da[j]!=0;j++){
                if(a.da[i]==b.da[j]){symbol=1;}
            }
        if (symbol==0){b.da[j]=a.da[i];}
        }
        b.Sort();
        for(i=0;b.da[i]!=0;i++){cout<<b.da[i]<<endl;}
        return 0;
    }
    

    sort函数按照节点所含的内容对节点进行排序。

    在使用链式存储的时候,各位朋友记住绝对不能动first(即改变first的内容),否则会造成链表丢失,变成人工制造的垃圾。

    展开全文
  • 练习题及解题思路 #include <stdio.h> #include "string.h" #include "ctype.h" #include "stdlib.h" #include "math.h" #include "time.h" #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OK...
  • 数据结构 线性表习题

    2020-04-17 12:12:22
    数据结构 线性表 线性表是最常用且简单的一种数据结构。 typedef struct tagnde{ ElemType date; // 任意数目,组合,类型的数据成员; struct tagnode *Ptr; // 指针域 指向相邻结点 }linknode,*...
  • 线性表主要采用哪两种存储结构?它们是如何存储数据元素的? 各有什么优缺点? 答案一 线性表是由n个类型相同的数据元素组成的有限序列,其中,元素类型可以是基本类型或类; 主要采用的有顺序存储结构和链式存储结构 ...
  • 王道数据结构线性表课后习题

    千次阅读 2018-05-30 10:01:14
    1.3长度为n的顺序表L,编写一个时间复杂度为O(n),空间复杂度为O(1)的算法,该算法删除线性表中所有值为x的数据元素 //解法一:用k标记不等于x的元素,将不等于x的元素向前放到k的位置上,修改L的长度 void del_x_1...
  • 数据结构线性表题库

    千次阅读 多人点赞 2018-08-01 14:28:02
    网络课课后 1、下面关于线性表的叙述中,正确的是 A、线性表采用顺序存储,必须占用一片连续的存储单元。 B、线性表采用顺序存储,便于进行插入和删除操作。 C、线性表采用链接存储,不必占用一片连续的存储...
  • 习题按类和方法区别

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,903
精华内容 1,561
关键字:

数据结构线性表习题

数据结构 订阅