精华内容
下载资源
问答
  • 线性表逆置

    千次阅读 2018-04-12 19:29:13
    问题描述:将一个线性表逆置,即:输入1 2 3 4 5 6;输出6 5 4 3 2 1;#include <iostream>#include <cstdlib>using namespace std;typedef int elemtype;typedef struct{ elemtype* ...

    问题描述:将一个线性表逆置,即:
    输入1 2 3 4 5 6;
    输出6 5 4 3 2 1;
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    typedef int elemtype;
    typedef struct{
     elemtype* elem;
     int listsize;
     int length;
    }sqlist;
    void create_L(sqlist& L){
     L.elem=(elemtype*)malloc(1000*sizeof(elemtype));
     L.listsize=1000;
     L.length=0;
    }
    void show(sqlist& L){
     for(int i=0;i<L.length;i++){
      cout<<L.elem[i]<<" ";
     }  
     cout<<endl;
    }
    void nizhi(sqlist& L){
    //法一,遍历半个数组,前后交换 :从前向后遍历L.elem[i]与L.elem[L.length-1-i]交换,与法二大同小异
     /* for(int i=0;i<L.length/2;i++){
       int t;
       t=L.elem[i];
       L.elem[i]=L.elem[L.length-1-i];
       L.elem[L.length-1-i]=t;  
         }*/
    //法二,记录数组的下标法:记录数组的下标,一个向后走,一个向前走,直至相等,否则就交换
         int low=0; 
         int high=L.length-1;
         while(low<high){
          int t=L.elem[low];
          L.elem[low]=L.elem[high];
          L.elem[high]=t;
          low++;
          high--;

      }
     } 
    void fuzhi(sqlist& L,int n){
     cout<<"请输入线性表的元素";
     int m;
     for(int i=0;i<n;i++){
      cin>>m;
      L.elem[i]=m;
      L.length++;
     }
    }
    int main(){
     sqlist l;
     create_L(l);
     fuzhi(l,5); 
     show(l);
     nizhi(l);
     show(l);
     return 0;
    }
    展开全文
  • 线性表逆置实验报告

    2021-03-22 15:36:46
    课程设计题目:线性表逆置实验 一、问题描述 试分别以顺序表和单链表作存储结构,各写一实现线性表就地逆置的算法。 二、基本要求 逆置线性表。 就地(空间复杂度至多O(1)O(1)O(1))。 三、概要设计 1. 数据结构的...

    课程设计题目:线性表逆置实验

    一、问题描述

    试分别以顺序表和单链表作存储结构,各写一实现线性表就地逆置的算法。

    二、基本要求

    1. 逆置线性表。
    2. 就地(空间复杂度至多 O ( 1 ) O(1) O(1))。

    三、概要设计

    1. 数据结构的设计

    依题目要求,本实验采用顺序表和单链表。

    2. 算法的设计

    对于顺序表的逆置,我们使用两个指针ij,分别从左到右和从右到左扫描,交换元素,直到相遇。

    伪代码如下

    void reverse() {
        for (int i = 0, j = length - 1, t; i < j; i++, j--)
            t = data[i], data[i] = data[j], data[j] = t;
    }
    
    时间复杂度空间复杂度
    O ( n ) O(n) O(n) O ( 1 ) O(1) O(1)

    对于单链表的逆置,我们使用按链表顺序对 Node 使用头插法。

    伪代码如下

    void reverse() {
        Node *p = first.next;
        first.next = NULL;
        for (; p;) {
            Node *s = p;
            p = s->next;
            s->next = first.next;
            first.next = s;
        }
    }
    
    时间复杂度空间复杂度
    O ( n ) O(n) O(n) O ( 1 ) O(1) O(1)

    四、详细设计

    1. 设计抽象数据类型对应的C++类定义

    即常规的顺序表和单链表,在此便不一一赘述了。

    2. 设计每个成员函数

    除上述void reverse()函数外,其余函数与常规的顺序表和单链表中的无异,在此便不一一赘述了。

    3. 设计主函数

    主函数主要包括设计测试数据并测试,输出逆置前和逆置后的结果。

    五、运行与测试

    1. 测试环境

    运行环境:Windows 20H2, i7-9750H @ 2.60GHz, 16GB RAM

    编译器:gcc version 8.1.0 (x86_64-posix-seh-rev0, Built by MinGW-W64 project)

    编译命令:-g

    运行终端:cmd

    2. 在调试程序的过程中遇到的问题与解决方案

    暂未发现异常。

    3. 程序清单及运行结果

    程序清单如下

    顺序表

    #include <iostream>
    using namespace std;
    
    const int MaxSize = 10; //10只是示例性的数据,可以根据实际问题具体定义
    struct SeqList
    {
        SeqList() { length = 0; }
        SeqList(int a[], int n)
        {
            if (n > MaxSize)
                throw "参数非法";
            for (int i = 0; i < n; i++)
                data[i] = a[i];
            length = n;
        }
        ~SeqList() {}
    
        void print()
        {
            for (int i = 0; i < length; i++)
                cout << data[i] << " ";
            cout << endl;
        }
    
        void reverse()
        {
            for (int i = 0, j = length - 1, t; i < j; i++, j--)
                t = data[i], data[i] = data[j], data[j] = t;
        }
    
        int data[MaxSize];
        int length;
    };
    
    int main()
    {
        int a[] = {0, 1, 2, 3, 4, 5};
        SeqList l(a, 6);
        l.print();
        l.reverse();
        l.print();
        return 0;
    }
    

    运行结果(符合预期)

    D:\OneDrive - mail2.sysu.edu.cn\MyDocuments\code\DSA\week04\线性表逆置>SeqList.exe
    0 1 2 3 4 5
    5 4 3 2 1 0

    单链表

    #include <iostream>
    using namespace std;
    
    struct Node
    {
        int data;
        Node *next;
    };
    
    struct LinkList
    {
        Node first = {-1, NULL};
        LinkList() {}
        LinkList(int a)
        {
            Node *s = new Node;
            *s = {a, NULL};
            first.next = s;
        }
        LinkList(int a[], int n)
        {
            Node *p = &first;
            for (int i = 0; i < n; i++)
            {
                Node *s = new Node;
                *s = {a[i], NULL};
                p->next = s;
                p = s;
            }
        }
        ~LinkList()
        {
            for (Node *p = first.next; p;)
            {
                Node *s = p;
                p = s->next;
                delete s;
            }
        }
    
        void print()
        {
            for (Node *p = first.next; p; p = p->next)
                cout << p->data << " ";
            cout << "\n";
        }
    
        void reverse()
        {
            Node *p = first.next;
            first.next = NULL;
            for (; p;)
            {
                Node *s = p;
                p = s->next;
                s->next = first.next;
                first.next = s;
            }
        }
    };
    
    int main()
    {
        int a[] = {0, 1, 2, 3, 4, 5};
        LinkList l(a, 6);
        l.print();
        l.reverse();
        l.print();
        return 0;
    }
    

    运行结果(符合预期)

    D:\OneDrive - mail2.sysu.edu.cn\MyDocuments\code\DSA\week04\线性表逆置>LinkList.exe
    0 1 2 3 4 5
    5 4 3 2 1 0

    六、总结与心得

    1. 单链表的就地逆置算法,除了利用头插法外,还可以翻转指针,详见《数据机构(C++版)学习辅导与实验指导》P23的算法2-4。

    七、参考资料

    1. 王红梅, 胡明, 王涛. 数据结构(C++版)[M]. 2 版. 清华大学出版社, 2011.
    2. 王红梅, 胡明, 王涛. 数据机构(C++版)学习辅导与实验指导[M]. 2 版. 清华大学出版社, 2011.
    展开全文
  • 10.7线性表逆置的算法

    千次阅读 2017-11-17 23:12:06
    //已知线性表A的长度为n, 试写出该线性表逆置的算法 #include #include #define MAXSIZE 20 typedef struct { int data[MAXSIZE]; //存储顺序表中的元素 int len; //顺序表的表长 }SeqList; //顺序表类型 ...
    //已知线性表A的长度为n, 试写出该线性表逆置的算法
    #include <stdio.h>
    #include <stdlib.h>
    
    #define MAXSIZE 20
    typedef struct
    {
    	int data[MAXSIZE];    //存储顺序表中的元素
    	int len;              //顺序表的表长
    }SeqList;                 //顺序表类型
    
    SeqList *Init_SeqList()   //顺序表初始化
    {
    	SeqList *L;
    	L = (SeqList *)malloc(sizeof(SeqList));
    	L->len = 0;
    	return L;             //返回指向顺序表的指针
    }
    
    void CreatList(SeqList **L) //生成顺序表
    {
    	int i, n;
    	printf("Input length of List: ");
    	scanf("%d", &n);
    	printf("Input element of List: \n");
    	for (i = 0; i< n; i++)
    	{
    		scanf("%d", &(*L)->data[i]);
    	}
    	(*L)->len = n;
    }
    
    void Coverts(SeqList *A)     //将顺序表中的元素逆置
    {
    	int i, n;
    	int x;
    	n = A->len;              //n 为线性表*A 的长度
    	for (i = 0; i < n / 2; i++)  //实现逆置
    	{
    		x = A->data[i];
    		A->data[i] = A->data[n-i-1];
    		A->data[n-i-1] = x;
    	}
    }
    
    void print(SeqList *L)       //输出顺序表
    {
    	int i;
    	for (i = 0; i < L->len; i++)
    	{
    		printf("%4d", L->data[i]);
    	}
    	printf("\n");
    }
    
    int main()
    {
    	SeqList *A;
    	A = Init_SeqList();       //顺序表初始化
    	printf("Creat List A:\n");
    	CreatList(&A);            //生成顺序表
    	printf("Output list A:\n"); 
    	print(A);                 //输出顺序表
    	
    	printf("Covert list A:\n");
    	Coverts(A);               //将顺序表中的元素逆置
    	printf("Output list A:\n");
    	print(A);
    
    	return 0;
    }

    展开全文
  • 数据结构-线性表逆置 C语言源码

    千次阅读 多人点赞 2019-03-17 13:05:28
    数据结构-线性表逆置 C语言源码 #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; struct NZ{ int*elem; int length; }; void ko(NZ&amp;amp; l,int n) { int hj; l....

    一家懂得用细节留住客户的3年潮牌老店我必须支持!➕🛰:luyao1931

    在这里插入图片描述

    数据结构-线性表逆置 C语言源码

    算法思想:

    将原始表里的元素取出来放在一个空表里,
    再将这个表从最后一个元素输出。

    #include<stdio.h>
    #include<stdlib.h>
    struct NZ{
    	int*elem;
    	int length;
    };
    void ko(NZ& l,int n)
    {
    		int hj;
    		l.elem=(int*)malloc(sizeof(int)*n);
    		for(int k=0;k<n;k++)
    		{
    		scanf("%d",&hj);
    		l.elem[k]=hj;	
    		}
    		l.length =n;
    }
    void xianshi(NZ l)
    {
    	for(int i=0;i<l.length ;i++)
    	{
    		printf(" %d ",l.elem[i]);
    	}
    }
    void nizhi(NZ &l)
    {
    	int j=l.length -1;
    	for(int i=0;i<l.length /2;i++)
    	{
    		int t=l.elem[i];
    		l.elem[i]=l.elem[j-i];
    		l.elem[j-i]=t;
    	}
    }
    main()
    {
    	int n;
    	printf("请输入表长");
    	scanf("%d",&n);
    	NZ l;
    	printf("\n开始输入表中元素");
    	ko(l,n);
    	nizhi(l);
    	xianshi(l);
    	printf("\n表长%d\n",l.length );
    	return 0;
    }
    

    在这里插入图片描述
    快看,这才是重点!我想能看到这里的同学,无外乎两种人:来拷贝代码的人 和 来拷贝代码的人。

    但,在拷贝走的时候,你要想清楚一件事,把代码拷走之后有个蛋用,搞明白对你来说才是最重要的。

    好了,就酱紫。

    老铁,这要是都不赞,说不过去吧!!!哦,对了,你这么好看,关注一下呗。。。

    最后对自己说:
    你现在所遭遇的每一个不幸,都来自一个不肯努力的曾经。

    展开全文
  • 实现链式线性表逆置,从链表处实现。代码简单,容易理解。
  • 线性表逆置(顺序表和单链表)

    千次阅读 多人点赞 2018-09-23 00:21:53
    这几天练习了下线性表逆置,顺序表比较简单,就是数组的位置交换。 顺序表的逆置 单链表的逆置 头插法 就地逆置 递归 顺序表的逆置: 中间变量temp,交换首位两个元素的位置。 void ListReverse...
  • 总体思想不多说,直接上代码,分为顺序表和链表两种 1.链表: void invert(LinkList L){ Node *p,*q; if(L->nexts==NULL){ Return; } P=L->next; q=p->next; p->next=NULL; while(q!......
  • void reverse(int a[], int length) { int head = 0; int tail = length - 1; while (head&lt;tail) { swap(a, head, tail); head++; tail--; } } void swap(int a[], int i, int... int temp = a[...
  • 线性表逆置 题号8559

    2020-10-26 21:24:53
    #include <iostream> #include<bits/stdc++.h> using namespace std; typedef struct{ int *data; }node; int main() { int n,t; cin>>n; node a; a.data=new int[n];... ...
  • 设有一个线性表E = { e1, e2, … , en - 1, en },设计一个算法,将线性表逆置,即使元素排列次序颠倒过来,成为逆线性表E’={ en , en-1 , … , e2 , e1 },要求逆线性表占用原线性表空间,并且用顺序表和单链表两...
  • 输入数据,输出数据,及线性表的长度,询问是否查找数据,若查找则由用户输入需查找的数据,显示此数据在线性表中的位置(第几个)*/#include#include#define NULL 0#define LEN sizeof(struct Node)struct Node{int ...
  • 线性表逆置

    千次阅读 2019-09-23 21:52:47
    设有一线性表e=(e1 , e2 , … , en-1 , en),其逆线性表定义为e’=( en , en-1 , … , e2 , e1),请设计一个算法,将线性表逆置,要求逆线性表仍占用原线性表的空间,并且用顺序表和单链表两种方法来表示,写出不同...
  • 线性表原地逆置代码

    2014-10-28 00:06:39
    线性表原地逆置代码, 用c++编写
  • 线性表逆置 手摇算法:liming−and−jenny→jenny−and−liming 线性表逆置: a[0],a[n]交换 a[1],a[n-1]交换 a[2],a[n-2]交换 a[3],a[n-3]交换……(i指向low,j指向high,当low<high运行) for(int i = ...
  • 数据结构实验中自己写的程序,实现线性表逆置。绝对可用!
  • 线性表逆置-链式结构 数据结构题目 设元素值为整型的线性表L,采用链式结构存储,编写函数,实现线性表的就地逆置 C++代码如下: #include <iostream> #include <stdlib.h> using namespace std; ...
  • 线性表的就地逆置

    千次阅读 2018-05-03 22:40:37
    试分别以不同的存储结构实现线性表的就地逆置算法,即在原表的存储空间将线性表(a1,a2,…,an)逆置为(an,an-1,…,a1)。(1) 以一维数组作存储结构。...分两行分别输出要求(1)和要求(2)的线性表逆置结果(a...
  • 设元素值为整型的线性表L,分别采用顺序结构和链式结构存储,编写函数,实现线性表的就地逆置
  • 这篇文章讲述的是数据结构部分的线性表逆置的java实现,如有错误或者不当之处,还望各位大神批评指正。 问题描述 请编写一个算法实现链表的逆置,如有初始链表L:1,2,3,4,5逆置后为L:5,4,3,2,1 算法分析 通过...

空空如也

空空如也

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

线性表的逆置