精华内容
下载资源
问答
  • 双向链表学生管理系统?怎么实现??跪求,各位大神指点迷津,谢谢
  • 初探双向链表

    2016-03-27 16:25:53
    但是导师给我电邮让我参加,我想干脆就抱个大腿吧,让大腿教教我怎么做项目,于是就找了个大二的学长。额,目前这件事还没有任何进展,可能是大腿要考研比较忙吧。由于刘同到高中母校演讲,最近又有电影上映,于是我...

          还是先来唠唠最近发生的事把。

        ok,拿到奖学金,被选为优秀团员,我一点感觉都没有。最近让我比较激动的是我参加了学校的盛特杯,这件事本来我是不想参与的,我觉得我还太弱,没有能力去做一个项目。但是导师给我电邮让我参加,我想干脆就抱个大腿吧,让大腿教教我怎么做项目,于是就找了个大二的学长。额,目前这件事还没有任何进展,可能是大腿要考研比较忙吧。由于刘同到高中母校演讲,最近又有电影上映,于是我就去买了《谁的青春不迷茫》来看。我靠,真的是一本烂的不能再烂的书啊,以后这种书坚决不自己买了,还是去图书馆看。

       今早上去图书馆对数据结构进行攻关,把双向链表的代码写出来了,双向链表就是在单向链表的基础上再加一个前驱,其他的大致都与单向链表差不多,主要包含初始化,插入删除查找的功能。

    #include<stdio.h>
    #include<stdlib.h>
    typedef int Elemtype;
    typedef struct DulNode
    {
        Elemtype data;
        struct DulNode *prior;
        struct DulNode *next;
    }DulNode,*Dulinklist;
    void InitDulNode(DulNode *head)// 创建一个双向链表的表头,前驱和后继都指向自己
    {
        head->prior=head;
        head->next=NULL;
    }
    
    DulNode *GetElemp_dul(DulNode *head,int i)
    {
        int j=1;
        DulNode *p=head->next;
        while(p!=NULL&&j<i)
        {
            p=p->next;
            j++;
        }
        if(j==i)
        {
            return p;
        }
        else
            return 0;
    }
    
    int Listinsert_Dul(DulNode *head,int pos,int e)//pos为要插入的位置,e为插入节点的值
    {
        DulNode *p;
        p=GetElemp_dul(head,pos);
        if(!p)
        {
            printf("pos error!\n");
            return 0;
        }
        DulNode *s;
        if(!(s=(Dulinklist)malloc(sizeof(DulNode))))
            return 0;
        s->data=e;
        s->prior=p->prior;
        p->prior->next=s;
        s->next=p;
        p->prior=s;
        return 1;
    }
    void Print(DulNode *head)
    {
        DulNode *p;
        p=head->next;
        while(p!=NULL)
        {
            printf("%d\t",p->data);
            p=p->next;
        }
    }
    void CreatDulNode(DulNode *head,int e)
    {
        DulNode *p;
        p=(DulNode *)malloc(sizeof(DulNode));
        p->data=e;
        p->next=NULL;
        if(head->next==NULL)
        {
            p->prior=head;
            head->next=p;
        }
        else
        {
            head->next->prior=p;
            p->next=head->next;
            p->prior=head;
            head->next=p;
        }
    }
    int Listdelete_Dul(DulNode *head,int i)
    {
        DulNode *p;
        p=GetElemp_dul(head,i);
        if(!p)
        {
            printf("delete pos error!\n");
            return 0;
        }
        p->prior->next=p->next;
        p->next->prior=p->prior;
        free(p);
        return 1;
    }
    int main()
    {
        DulNode *head;
        head=(DulNode *)malloc(sizeof(DulNode));
        int i;
        InitDulNode(head);
        for(i=0;i<10;i++)
        {
            CreatDulNode(head,i);
        }
        Listinsert_Dul(head,4,100);
        Listdelete_Dul(head,4);
        Print(head);
        return 0;
    }
        这代码还是花了我1个多小时才写出来的,哎,太花时间了。

    展开全文
  • 单、双向链表操作

    2019-03-08 16:49:05
    昨天的笔试题有一个双向链表的操作,我本来很有自信的,怎么老是感觉错了? woc 单链表的增加和删除 /** * @author JZWen * @date 2019年3月8日 */ package getoffer; /** * @author JZWen * */ ...

    昨天的笔试题有一个双向链表的操作,我本来很有自信的,怎么老是感觉做错了?  woc

     

    单链表的增加和删除

    /**
     * @author JZWen
     * @date  2019年3月8日
     */
    package getoffer;
    
    /**
     * @author JZWen
     *
     */
    public class SimpleLinked {
    
    	
    	public static int delete(LinkNode linkNode , int i) {
    		LinkNode curr = linkNode;
    		if(curr == null) {
    			return 0;
    		}
    		int len = 0;
    		while(curr != null) {
    			len ++;
    			if(len == i) {
    				
    				if(curr.next == null) {
    					return 1;
    				}
    				//重点,删除
    				curr.next = curr.next.next;
    				return 1;
    			}
    			curr = curr.next;
    		}
    		//长度太长了
    		return 0;
    	}
    	
    	public static int insert(LinkNode linkNode , int i , int value) {
    		
    		LinkNode curr = linkNode;
    		if(curr == null) {
    			return 0;
    		}
    		int len = 0;
    		while(curr != null) {
    			len ++;
    			if(len == i) {
    				//插入操作
    				LinkNode newNode = new LinkNode(value);
    				newNode.next = curr.next;
    				curr.next = newNode;
    				return 1;
    			}
    			curr = curr.next;
    		}
    		//长度太长了
    		return 0;
    	}
    	
    	
    	
    	
    	public static void print(LinkNode linkNode) {
    		LinkNode curr = linkNode;
    		while(curr != null) {
    			System.out.println(curr.value);
    			curr = curr.next;
    		}
    	}
    	
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		LinkNode linkNode = new LinkNode(1);
    		LinkNode linkNode1 = new LinkNode(2);
    		LinkNode linkNode2 = new LinkNode(4);
    		linkNode.next = linkNode1;
    		linkNode1.next = linkNode2;
    		insert(linkNode , 2, 3);
    		delete(linkNode, 2);
    		print(linkNode);
    	}	
    
    }
    
    class LinkNode{
    	
    	LinkNode next;
    
    	int value;
    	
    	public LinkNode() {}
    	
    	public LinkNode(int value) {
    		this.value = value;
    	}
    	
    }

     

    单链表翻转  还有头插法,还有就地解决法

    //反转链表
    	public LinkNode fanzhuan(LinkNode linkNode) {
    		//最简单的方法就是,有一个堆栈存储链表节点,以最先出栈的为头结点。
    		Stack<LinkNode> stack = new Stack<>();
    		while(linkNode != null) {
    			stack.push(linkNode);
    			linkNode = linkNode.next;
    		}
    		LinkNode head = new LinkNode();
    		if(!stack.isEmpty()) {
    			head = stack.pop();
    		}
    		LinkNode node = head;
    		while(!stack.isEmpty()) {
    			node.next = stack.pop();
    		}
    		return head;
    	}

     

    单链表排序 , 使用的是类似于现在排序的算法。

    *******************************************************刚看一下手机,作业帮约我下周面试。*************woc有点慌啊

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 在使用双向链表实现内存的置换算法,我们需要了解双向链表的数据结构是怎么样的。 双向链表是链式结构的,可以理解成蚯蚓,两头都可以进行操作,一个节点连着一个节点。每一个节点都存储着上一个节点和下一个节点的...

    最近学了一门关于计算机网络的课程,把所学知识做一个总结,程序员不做技术积累还是不行的。第一次写Blog,慢慢积累吧,废话不多说,开始!

    双向链表

    在使用双向链表实现内存的置换算法,我们需要了解双向链表的数据结构是怎么样的。

    双向链表是链式结构的,可以理解成蚯蚓,两头都可以进行操作,一个节点连着一个节点。每一个节点都存储着上一个节点和下一个节点的地址。
    双向链表



    好了,双向链表大致的结构就是这样,接下来就开始来实现它吧。

    因为双向链表是需要一个一个节点串联起来的,首先需要来定义节点Node,这里我使用python语言来实现。

    class Node:
        def __init__(self, key, value):
            self.key = key
            self.value = value
            self.next = None
            self.prev = None
    
        def __str__(self):
            val = "{%s}: {%s}" % (self.key, self.value)
            return val
    

    这里的__str__是一个魔法方法,调用print()方法输出Node类的实例,会直接输出__str__魔法方法中的返回值。

    实现完Node类之后,就可以实现双向链表了。实现之前我们可以先构思一下双向链表有哪些操作,也就是方法,然后如何去初始化。


    DoubleLinkedList

    1. 初始化
    2. 双向链表的操作
      (1). 从头部取出数据 / 删除头部数据
      (2). 从尾部取出数据 / 删除尾部数据
      (3). 从双向链表中删除任一节点

    下面附上代码:
    class DoubleLinkedList:
        def __init__(self, capacity=sys.maxsize):
            self.capacity = capacity
            self.size = 0
            # 头部指针和尾部指针
            self.head = None
            self.tail = None
    
        # 从头部添加节点
        def __add_head(self, node):
            # 如果head为空,也就是双向链表中没有node
            if not self.head:
                self.head = node
                self.tail = node
                self.head.next = None
                self.head.prev = None
            else:
                node.next = self.head
                self.head.prev = node
                self.head = node
                self.head.prev = None
            self.size += 1
            return node
    
        # 从尾部添加节点
        def __add_tail(self, node):
            # 如果tail为空,也就是双向链表中没有node
            if not self.tail:
                self.tail = node
                self.head = node
                self.tail.prev = None
                self.tail.next = None
            else:
                node.prev = self.tail
                self.tail.next = node
                self.tail = node
                self.tail.next = None
            self.size += 1
            return node
    
        # 删除尾部节点
        def __del_tail(self):
            # 链表中没有节点
            if not self.tail:
                return
    
            node = self.tail
            if node.prev:
                self.tail = node.prev
                self.tail.next = None
            else:
                self.tail = self.head = None
            self.size -= 1
            return node
    
        # 删除头部节点
        def __del_head(self):
            # 链表中没有节点
            if not self.head:
                return
    
            node = self.head
            if node.next:
                self.head = node.next
                self.head.prev = None
            else:
                self.head = self.tail = None
            self.size -= 1
            return node
    
        # 删除任一节点
        def  __remove(self, node):
            # 如果为None,默认删除尾部节点
            if not node:
                node = self.tail
    
            if node == self.tail:
                self.__del_tail()
            elif node == self.head:
                self.__del_head()
            else:
                node.prev.next = node.next
                node.next.prev = node.prev
                self.size -= 1
            return node
    
        # 弹出头部节点,删除并返回
        def pop(self):
            return self.__del_head()
    
        # 添加节点
        def append(self, node):
            return self.__add_tail(node)
    
        # 往头部添加节点
        def append_front(self, node):
            return self.__add_head(node)
    
        # 删除节点
        def remove(self, node=None):
            return self.__remove(node)
    
        # 打印链表
        def print(self):
            p = self.head
            line = ""
            while p:
                line += "%s" % p
                p = p.next
                if p:
                    line += " => "
            print(line)
    

    前面有双下滑线的为私有方法,这里封装的pop(), appned()等为供外部使用的API。

    展开全文
  • 嗯不知道牛客难度标记是不是越小越不好,很魔性。 正题: 先来看一棵简单的二叉搜索树 由他变成一个有序的双向链表还是比较简单的。如下图: 接下来升级二叉搜索树的复杂程度 他怎么变呢?先变简单的把它的子树...

    题目描述:
    输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点,只能调整树中结点指针的指向。

    题目分析
    这道题怎么说呢,牛客标它的难度是最低的这我是不太认同的。首先从题目描述来看,不读个3、4遍可能不知道它是什么意思,同时又考察了链表和二叉树这两种结构。嗯不知道牛客难度标记是不是越小越不好做,很魔性。

    正题:
    先来看一棵简单的二叉搜索树
    在这里插入图片描述
    由他变成一个有序的双向链表还是比较简单的。如下图:
    在这里插入图片描述
    接下来升级二叉搜索树的复杂程度
    在这里插入图片描述
    他怎么变呢?先变简单的把它的子树先转成链表
    在这里插入图片描述
    接下来改变根节点的指针指向,把它链到3、5中间
    在这里插入图片描述
    到这里我们基本上可以这道题要采用什么方法了,还是树的常用操作——递归。但是每次做些什么?
    一个节点和三个节点组成的子树操作是相同的,只需把此子树的左右子节点回链子树根节点即可。
    接下来就要考虑向上图这样更高一层的树了。
    子树成链表就不用说了,重点是怎么把根节点链到中间去。首先上面根节点开始指针指的是2和6,我们要做的操作是修改指向,让它指3和5.故涉及到链表找节点的问题(这在链表操作很常见,看操作即可)指向完了,回链即可。

    代码实现:

    /* function TreeNode(x) {
        this.val = x;
        this.left = null;
        this.right = null;
    } */
    function Convert(pRootOfTree)
    {
        // write code here
        if(pRootOfTree==null){
            return null;
        }
         //找左子树最右
        function find_right(node){
            while(node.right){
                node=node.right;
            }
            return node;
        }
        //拿左子树链表
        let leftNode = Convert(pRootOfTree.left);
        //拿右子树右子树
        let rightNode = Convert(pRootOfTree.right);
        //链表头节点
        let  retNode = leftNode;
        if(leftNode){
            //若左子树链表存在,则找其最右
             leftNode = find_right(leftNode);
        }else{
            //不存在左子树则根节点就作为链表头节点
            retNode = pRootOfTree;
        }
        
          //pRootOfTree的左子结点链上leftNode
            pRootOfTree.left = leftNode;
            //pRootOfTree的右子结点链上右子结点
            pRootOfTree.right = rightNode;
            //回链
            if(leftNode){
                 leftNode.right = pRootOfTree;
            }
            if(rightNode){
               rightNode.left = pRootOfTree;
            }
            //返链表头节点
            return retNode;
        
        
    }
    

    在这里插入图片描述

    展开全文
  • 用 JAVA 实现双向链表

    千次阅读 2019-01-28 23:23:05
    Java 不让人对内存任何操作。为了让人放弃直接操作内存的想法,甚至佯装没有指针。 Java 虚拟机有一个垃圾回收机制,负责释放 / 回收无用对象所占用的内存空间,从而防止内存泄漏(内存泄漏是指,程序中分配的堆...
  • 第一步预处理出来每个城市最近的城市和第二近的城市,这一步怎么做呢?先按高度排序O(nlogn)O(nlogn)O(nlogn),再以排序后的元素建一个双向链表。这样按照原来读入的顺序枚举每个元素,找枚举元素的左一位,左两位,...
  • 题目描述 输入一棵二叉搜索树,将该二叉搜索树转换成...这道题真没想到该怎么做,思路比较混乱 看完CYC大神的才会做 /** public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; ...
  • “队列”(Queue)就是等待某事而排成的队;描述一种先入先出 FIFO(First Input First Out) 参考:《计算机是怎么跑起来的》-[日]矢泽久雄 第6.4章节 2.实现方式 用双向链表 import ja...
  • 双向链表 在单链表的基础上增加了前缀结点,一定程度上提升了查找元素的速度 在查找元素时,可以反向查找前缀结点 插入结点过程(分为4步) 这四个步骤的顺序可调整,但是必须要保证需要的链不断!!...
  • 怎么读呢?因为二叉搜索树的中序遍历是有序的,所以用中序遍历来读到queue中。(方法一) 递归的来。假设convert函数能拿到一个排好序的双向链表。我们把它与当前结点拼接在一起即可。(方法二) 方法一 import ...
  • 一网友对算法感兴趣,不知怎么得到了我的QQ号,加为好友。给我发来了微软面试题100题,让我。我也正好想准备年底找工作的事儿,一举两得,就试试上面题目的难度。  第一道题是把二元查找树转变成排序的...
  • 前言上一次我们讲到了数据结构:栈和队列,并对他们的运用了一些介绍和案例实践;我们也讲到了怎么简单的实现一个四则运算、怎么去判断标签是否闭合完全等等,anyway,今天接着和大家介绍一些数据结构:链表链表是...
  • 把二叉树转换成双向链表

    千次阅读 2013-05-08 11:26:33
    记得这是一道微软的面试题,想了很长时间不知道怎么做,近期看别人的博客,找到了算法,自己实现了一下,下面是算法的叙述: 1. If left subtree exists, process the left subtree …..1.a) Recursively ...
  • * 输入一颗二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。 * 要求不能创建任何新的节点,只能调整树中节点指针的指向。 *  * */ 然后基本要实现的功能就是这样子的: 怎么实现呢? ...
  • 一网友对算法感兴趣,不知怎么得到了我的QQ号,加为好友。给我发来了微软面试题100题,让我。我也正好想准备年底找工作的事儿,一举两得,就试试上面题目的难度。 第一道题是把二元查找树转变成排序的双向...
  • 双链表的功能是实现了,可其前指针域貌似没怎么使用。 于是我把双链表代码推倒重来,在实现双链表的过程中,尽可能多的使用前指针域。不这样的话,那双链表跟单链表有什么区别?双链表的存在意义何在? 一、谈谈...
  • 算法提高 盾神与条状项链 时间限制:1.0s 内存限制:256.0MB 问题描述  有一天,盾神捡到了好多好多五颜六色的珠子!他心想这些珠子这么漂亮,... 盾神自知审美不是他的长项,于是他很谦虚地请教土方,怎么...
  • 由于这些题实在太火了所以应广大网友建议要求在此把之前已整理公布的前 80 题 现在一次性分享出来此也算是前 80 题第一次 集体亮相 此些题已有...把二元查找树转变成排序的双向链表 题目 : 输入一棵二元查找树将该二
  • 由于这些题实在太火了所以应广大网友建议要求在此把之前已整理公布的前 80 题 现在一次性分享出来此也算是前 80 题第一次 集体亮相 此些题已有...把二元查找树转变成排序的双向链表 题目 : 输入一棵二元查找树将该二
  • O/R Mapping 双向多对多

    2008-11-20 01:34:30
    O/R Mapping 双向多对多 默认的中间只有俩个列,分别为另俩张表的主键 但是我现在想在中间中再另外加个列 ...要怎么做 有注释可以做么?或者@JoinTable里有没有什么属性可以给这张中间加个列
  • 链表在C++语言中是比较常要的技术,比如在游戏时可以记录人物行走路线,一些用数组难以实现的功能用链表可以轻松实现。那么在C++语言中是链表是怎么...我们只要理解单向链表,那么双向链表也就明白是怎么回事呢,请...
  • 总结写在前面的 在复习数据结构的过程中对于链表的操作总是容易忘记,时不时的就不知道具体的该怎么操作了,所以把这几个比较细节的地方总结一下,让自己印象加深一下,给之后的学习个参考。 接下来主要总结一下...
  • 转(C++链表)

    2013-05-17 23:00:00
    那么在C++语言中是链表是怎么实现的呢。下面主要讲解一下。。 2 3 链表实际上就像是自行车里的链条,一环接着一环。在链表里常用指向自身类得NEXT指针来和下一个链表节点联系。而双向链表主要就是添加一个...
  • 其本质是用一种类似继承的方式来实现 generic 的链表操作,但是我们都知道,c 是没有继承的,那么怎么做呢? 首先来看我们的 "base class", 以及其的一些基本操作 // circular list,双向循环链表 typedef struct...
  • 前言: 刷leetcode的每日一题的时候碰到这...leetcode上提到了这题的解法最好是希望我们自己能用HashMap+双向链表的解法手动造轮子去实现的。我最开始也是这么的。写了一个下午,提交无数遍终于通过了之后发现官方题
  • #计算互相关注的SQL应该怎么写 用户好友关系是一个产品的核心数据,只允许互相关注的用户之间发消息称为强关系型产品,比如微信;反之,不互相关注也能看到动态,比如微博,就是弱关系型产品 因为微信的存在,现在...
  • 一个Z妹子讲情了思路,一个M妹子提供了更高级的双向循环链表的代码借鉴(虽然有些还是没怎么看懂。。。 我的作业就完成啦!保存代码当个纪念! 1,往操作位置顺时针的下一位插入一个元素,并将操作位置移到...
  • 看了李先静的系统程序员成长计划(http://blog.csdn.net/absurd/category/474960.aspx?PageNumber=5)觉得很有道理,打好基础对以后很有好处,高层的东西再...先用C实现一个双向链表。 #include #include #include #incl

空空如也

空空如也

1 2 3 4
收藏数 79
精华内容 31
关键字:

双向表怎么做