精华内容
下载资源
问答
  • 顺序存储结构借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系,数据元素存放在一片连续的储存空间里,通常用数组来实现。顺序存储结构中,逻辑上相邻的两个元素在物理位置上也相邻;在给长度变换...

    一 、线性表

            线性表是由n(n>=0)个相同的数据元素(结点)组成的有限序列。顺序存储结构借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系,数据元素存放在一片连续的储存空间里,通常用数组来实现。顺序存储结构中,逻辑上相邻的两个元素在物理位置上也相邻;在给长度变换较大的线性表预先分配空间时,必须按最大存储空间分配;表的容量难以扩充。

    线性表的基本操作:

    1.  初始化操作

      初始条件,线性表不存在;操作结果:创建一个空的线性表

    2. 插入操作(InsertNode(T a,int i))

      初始条件:线性表存在,插入位置正确

    3. 删除操作DeleteNode(int i)

      初始条件:线性表存在且不为空删除位置正确

    4. 取表元素(SearchNode(int i))

      初始条件:线性表存在,所取元素位置正确

    5. 定位元素(SearchNode(T value))

      初始条件:线性表存在

    6. 求表长度(Getlength())

      初始条件:线性表存在

    7. 清空操作(Clear())

      初始条件:线性表存在且有数据元素

    8. 判断线性表是否为空(IsEmpty())

      初始条件:线性表存在

    将上述操作定义在接口ILinarList中,代码如下:

    Interface  ILinarList <T>
    
    {
    
    void InsertNode(T a,int i);   //插入操作
    
    void DeleteNode(int i);     //删除操作
    
    T SearchNode(int i);     //查找表元素
    
    T SearchNode(T value);  //定位元素
    
    int Getlength();         //求表长度
    
    void Clear();            //清空操作
    
    bool IsEmpty();         //判断线性表是否为空
    
    }

    二、就地逆置的算法思想:

            逆置后的线性表是将原表相应位置的元素进行交换,即交换第一个和最后一个,第二个和倒数第二个,依此类推,我们通过新建一个变量来存储值,以实现交换的目的,代码如下:

    class inversion
        {
            static void Main(string[] args)
            {
    
                Console.WriteLine("输入最大储存空间");
                int maxsize = int.Parse(Console.ReadLine());
                SeqList<int> SeqList = new SeqList<int>(maxsize);
                Console.WriteLine("输入元素个数");
                int length = int.Parse(Console.ReadLine());
                for (int i = 0; i < length; i++)
                {
                    Console.WriteLine("输入第{0}个元素值", i + 1);
                    SeqList.InsertNode(int.Parse(Console.ReadLine()));
                }
                for (int i = 0; i < length; i++)
                {
                    Console.WriteLine("第{0}个元素的值是:{1}", i + 1, SeqList.Data[i]);
                }
                int a = 1;
                int b = SeqList.Length;
                while (a < b)
                {
                    int t = SeqList.Data[a - 1];
                    SeqList.Data[a - 1] = SeqList.Data[b - 1];
                    SeqList.Data[b - 1] = t;
                    a++;
                    b--;
                }
                Console.WriteLine("就地逆置结果为:");
                for (int i = 0; i < length; i++)
                {
                    Console.WriteLine("第{0}个元素的值为:{1}", i + 1, SeqList.Data[i]);
                }
                Console.ReadLine();
    
    
            }
        }
    }
    

    三、实现结果:

           

    转载于:https://my.oschina.net/u/3717557/blog/1787391

    展开全文
  • c++代码表述的数据结构中链表逆置。代码结构还不错
  • 数据结构期中试题之单链表的基本操作c语言 一定义单链表的结构及操作主程序中的功能需要按照如下步骤顺序一一实现30分 初始化单链表L 依次插入a,b,c,d,e元素 输出单链表L; 输出单链表L的长度 判断单链表L是否为空 ...
  • 数据结构】单链表逆置:头插法图解

    万次阅读 多人点赞 2018-09-12 22:06:23
    算法思想:逆置链表初始为空,表节点从原链表依次“删除”,再逐个插入逆置链表表头(即“头插”到逆置链表),使它成为逆置链表“新”第一个结点,如此循环,直至原链表为空。 LNode *Inverse(LNode ...

    利用头插法能重新建立带头节点的新链表

    下面简单介绍一下,算法思想结合图示看

    算法思想:逆置链表初始为空,表中节点从原链表中依次“删除”,再逐个插入逆置链表的表头(即“头插”到逆置链表中),使它成为逆置链表的“新”的第一个结点,如此循环,直至原链表为空。

    LNode *Inverse(LNode *L)
    {
    	LNode *p, *q;
    	p = L->next;
    	L->next = NULL;
    	while (p != NULL)
    	{
    		q = p;
    		p = p->next;
    
    		q->next = L->next;
    		L->next = q;
    	}
    	return L;
    }

    接下来,进行图解:

    刚开始是这样

    ’循环前的操作

    进入循环,分别用q和p记录第一个和第二个节点

    
     

     进入第二轮循环,这是发生重大变化的关键时期

     这张图调整一下

     直到链表为空


    这篇文章已经一年半了,还是源源不断有不同的评论,去探讨相关的问题,其实图解不一定清晰。下面用更简明的方式给大家说一下什么情况。

    这里采用Java的写法,C一定也能看懂。

    我首先创建三个节点,一个是当前节点cur、一个是cur上一个节点pre。另外就是tmp。

    每次循环,我用tmp记录cur下一个节点,接着将cur的next指针指向上一个节点pre。这个时候就完成了一次反转操作。

    接着将pre和cur的记录往后移动一次,重复上面的操作。

    直至达到链表结尾。

    class Solution {
    	public ListNode reverseList(ListNode head) {
    		//申请节点,pre和 cur,pre指向null
    		ListNode pre = null;
    		ListNode cur = head;
    		ListNode tmp = null;
    		while(cur!=null) {
    			//记录当前节点的下一个节点
    			tmp = cur.next;
    			//然后将当前节点指向pre
    			cur.next = pre;
       
    			//pre和cur节点都前进一位
    			pre = cur;
    			cur = tmp;
    		}
    		return pre;
    	}
    }

     

    展开全文
  • 这个算法是用来实现数据结构中的就地逆置算法的。
  • 单链表的逆置-大概思想就是新建立一个头结点,然后让之前的结点使用头插法插入到新建立的链表。(这个也是使用快慢指针判断回文串前半部分逆置的思想(我感觉是这样的)) //实现单链表的逆置 //逆置单链表就是...
    11.25-学习笔记
    单链表的逆置-大概思想就是新建立一个头结点,然后让之前的结点使用头插法插入到新建立的链表中。(这个也是使用快慢指针判断回文串中前半部分逆置的思想(我感觉是这样的))
    //实现单链表的逆置
    //逆置单链表就是新创建一个链表,然后让原始列表的每一个结点使用头插法插入到新链表中。 
    #include<stdio.h>
    #include<stdlib.h>
    typedef struct node{
    	int data;
    	struct node * next;
    }Lnode,*Linklist;
    //使用尾插法创建单链表
    Linklist creat()
    {
    	Linklist L;
    	Lnode *s;
    	Lnode *q;	
    	int e;
    	L=(Linklist)malloc(sizeof(Lnode));
    	L->next=NULL;
    	q=L;
    	while(1)
    	{
    		printf("请输入想要建立的链表元素(9999结束)\n");
    		scanf("%d",&e);
    		if(e!=9999)
    		{
    			s=(Linklist)malloc(sizeof(Lnode));
    			s->next=q->next;
    			q->next=s;
    			s->data=e;
    			q=s;
    		}
    		else
    		break;		
    	}
    	q->next=NULL;
    	return L;
     } 
    void pri(Linklist L)
     {
     	L=L->next;
     	printf("当前的元素为:");
     	while(L!=NULL)
     	{
     		printf("%d",L->data);
     		L=L->next;
    	 }
     }
     int length(Linklist L)
     {
     	int num=0;
     	L=L->next;
     	while(L!=NULL)
     	{
     		num++;
     		L=L->next;
    	}
    	 return num;
     }
    Linklist resever(Linklist L)
    {
    	Lnode *s;
    	Linklist q;
    	int count;
    	count=length(L);
    	printf("count=%d",count);
    	q=(Linklist)malloc(sizeof(Lnode));
    	q->next=NULL;
    	L=L->next; //从第一个结点开始 
    //	for(int i=0;i<count;i++)
    //在这里开始我的编译器存在问题,一直循环不出来,我以为是我的循环条件没控制对,因此我就换了一种循环书写,结果还是出不来。然后我重启了电脑就行了。
    ///	{
    //		s=(Linklist)malloc(sizeof(Lnode));//申请一个s结点 
    //		s->data=L->data; 
    //		s->next=q->next;
    //		q->next=s;
    //		L=L->next;
    //	//	printf("%d",length(q));		
    //	}	
    	while(L!=NULL)
    	{
    		s=(Linklist)malloc(sizeof(Lnode));//申请一个s结点 
    		s->data=L->data; 
    		s->next=q->next;
    		q->next=s;
    		L=L->next;
    	}
    	printf("ok\n");
    	return q;
    }
    int main()
    {
    	Linklist L,q;
    	L=creat();
    	pri(L);
    	q=resever(L);
    	pri(q);
    	return 0;
     } 
    

    大概思想就是我画的这样:
    在这里插入图片描述

    展开全文
  • java数据结构之单链表逆置算法

    千次阅读 2018-08-21 19:39:30
    设计思想:在链表类中新加成员方法getNode(int i),用来获取指定位置节点,新建一个空单链表,将原链表每个节点按照从后往前顺序依次取出,再把节点的数据依次添加到新链表。 public Node getNode(int i...

    单链表逆置算法1

    设计思想:在链表类中新加成员方法getNode(int i),用来获取指定位置的节点,新建一个空单链表,将原链表的每个节点按照从后往前的顺序依次取出,再把节点的数据依次添加到新的链表中。

    public Node getNode(int i)//获取指定位置的节点
        {
            Node curr;
            curr=this.head.getNext();
            int j=0;
            while(curr!=null&&j<i)
            {
                curr=curr.getNext();
                j++;
            }
            return curr;
        }

    这种方法的缺点是需要重新创建一个空链表,下面演示就地逆置。

    单链表逆置算法之就地逆置

    算法思路

    SingList sl=new SingList();
    
            int s[]={10,9,8,7,6,5,4,3,2,1,0};
            for(int i=0;i<s.length;i++)
            {
                sl.add(Integer.valueOf(s[i]));
            }
            for(int i=1;i<sl.size();i++)
            {
                Object o=sl.delete(sl.size()-1);
                sl.insert(i-1, o);
            }
            for(int i=0;i<sl.size();i++)
            {
                System.out.print(sl.getDate(i)+" ");
            }
    展开全文
  • 数据结构中链表是其中很重要的一部分,那么就以单链表的逆置为例,大体回顾链表的头插 单链表的逆置算法思想:先让头结点指向空,定义一个指针P指向原来头结点的next域,在定义一个指针q和p指向同一个位置,p是用来...
  • 数据结构实验自己写的程序,实现线性表的逆置。绝对可用!
  • 链表的逆置: 将一个链表进行逆置: 如:10-->20-->30-->40 逆置后40-->30-->20-->10 分析: 方法一: 新建链表:遍历旧链表,将旧链表的结点依此头插到新链表。 上代码: #include <...
  • c语言数据结构中单链表原地逆置

    千次阅读 2016-10-27 20:41:44
    单链表运用单链表原地逆置,刚出炉代码,已在VS上编译运行成功,代码如下: #include "stdafx.h" #include #include #define OK 1 #define TURE 1 #define ERROR 0 #define FALSE 0 #define OVERFLOW -1 #define...
  • 408真题-数据结构-顺序表中逆置的应用 需求:设计一个时间与空间效率均较高算法,完成将R保存序列(X0,X1…,Xn-1)循环左移p(0<p<n)个位置转换成(Xp,Xp+1…Xn-1,X0,X1,…Xp-1)功能。 1.设计思想 ...
  • 数据结构中单链表就地逆置算法,不是程序设计代码
  • 数据结构中利用栈将单链表逆置,能有效地训练单链表和栈一些用法
  • 数据结构之单链表原地逆置

    千次阅读 2017-11-15 22:23:14
    数据结构之单链表原地逆置: 算法思想: 从单链表第一个结点开始,用头插法再次插入链表,此时,链表元素次序就是原来顺序逆序。 代码:#include #include #define ElemType int #define maxsize 20...
  • 数据结构 链表的逆置     本人经过长时间的理解,终于发现链表的逆置其实就是逆序建立链表的过程,只不过现在不用建立新的结点,不用分配内存空间而已,我们只是需要把链表后面的结点拆出来,再按照...
  • 数据结构:单链表就地逆置

    千次阅读 2018-10-07 11:56:02
    6-1 带头结点的单链表就地逆置(10 分) ...L)要求在不新开辟节点的前提下将单链表中的元素进行逆置,如原单链表元素依次为1,2,3,4,则逆置后为4,3,2,1。 函数接口定义: void ListReverse_L(LinkList &...
  • 将la中的元素进行逆置,即la={an,an-1,…a1} */ # include <iostream> # include <stdlib.h> # include <stdio.h> using namespace std; typedef struct Node { int elem; struct Node *next;...
  • 数据结构,串操作 链式存储 逆置子串 ***题目3: 若S和T是用结点大小为1单链表存储两个串,设计算法将S首次与T匹配子串逆置
  • 在C语言为了减少时间和空间,对单链表采用就地逆置的方法,话不多说,完整代码如下。 #include<stdio.h> #include<malloc.h> #define LEN sizeof (struct Node) struct Node { int data;//定义数据域...
  • 数据结构——单循环链表的逆置

    千次阅读 2017-09-22 10:19:37
    将带头节点单循环链表逆置方法一:普通循环方法,通俗讲,只要把每一个结点指向它本来前一个即可,就像是直接改变了链表概念图箭头方向,这一方法就是使用普通循环打成这个过程。 C语言代码实现:void ...
  • 数据结构-实现一个单链表的逆置 1:这是一个经常被问到的面试题,也是一份非常基础的问题。比如一个链表是这样的: 1->2->3->4->5通过逆置后成为5->4->3->2->1。 最容易想到的方法是...
  • 1、在原有单链表,将单链表实现逆置。 (即不增加新结点) 2、程序要求单链表内容由用户输入,并分别显示出逆置前和逆置单链表。 问题:存入数据,打印出逆置链表后,在vs里停止运行,在Dev-c++...
  • 这篇博客主要阐述单链表合并与逆置,本人学习编程时间也不是很久,如果在下面文章有讲解不周或有误地方,欢迎各位大佬指正。 首先我们来熟悉一下单链表的结构: 1.单链表的结构 单链表是由一系列结点...
  • 仅使用少量工作变量以及对队列和栈的基本操作,编写一个算法,将队列Q中的所有元素逆置。 【输入形式】 输入的第一行为队列元素个数,第二行为队列从首至尾的元素 【输出形式】 输出队列的逆置 【样例输入】 3 1 2 3...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 372
精华内容 148
关键字:

数据结构中的逆置

数据结构 订阅