精华内容
下载资源
问答
  • 约瑟夫循环链表

    2011-11-25 22:23:58
    数据结构实验上机题 约瑟夫循环链表 里面有详细代码和详细实验报告以及测试截图
  • 约瑟夫的故事大家应该都有所耳闻吧,我第一次接触类似约瑟夫问题的话,应该是小学的时候班里大家一起做游戏,数到某个数(1~9)的倍数或者以该数结尾的话,数到的同学就要跳过该数说出下一个数,错了的话,要受惩罚或表演一...

    忍不住再发一篇吧.哈哈~~
    约瑟夫的故事大家应该都有所耳闻吧,我第一次接触类似约瑟夫问题的话,应该是小学的时候班里大家一起做游戏,数到某个数(1~9)的倍数或者以该数结尾的话,数到的同学就要跳过该数说出下一个数,错了的话,要受惩罚或表演一个节目然后退出游戏,接着又从1开始数起,直到剩下最后的那个同学,而且最后那个同学有奖励喔.虽然与约瑟夫问题有点区别,但是纯属雷同对吧.
    上课的游戏归上课的游戏,而如果对约瑟夫故事很感兴趣的同学也可以百度一下,在这码路上我们还是欣赏下约瑟夫在码路上的风景吧!

    public class Test{
        public static void main(String[] args){
            int total = 9;
            int num = 3;
            Object n = Joseph.winner(total, num);
            System.out.println(n.toString());		
        }
    }
    public class Joseph{
        public static Object winner(int total, int num) {
    		Node<Integer> head = null;//首节点
    		Node<Integer> pre = null;//当前节点
    		for(int i = 1; i <= total; i++) {//遍历所有参加的人,创建循环链表
    			if(i == 1) {//如果是首节点
    				head = new Node<>(i, null);//初始化首节点
    				pre = head;//首节点为当前节点
    				continue;
    			}
                //如果不是首节点
    			Node<Integer> newNode = new Node<>(i, null);//创建一个新节点
    			pre.next = newNode;//为当前节点存储下个节点
    			pre = newNode;//将新节点设为当前节点
    			if(i == total) {//如果当前节点是total说明是最后一个节点
    				pre.next = head;//将最后一个节点的下个节点存储为首节点
    			}
    		}
    		int count = 0;//为游戏计数初始化
    	    Node<Integer> n = head;//从首节点开始遍历
    	    Node<Integer> before = null;//before为当前节点的上一个节点
    	    while(n != n.next){//游戏开始
    	        count++;
    	        if(count == num){//报数到指定的那个数时
    	            before.next = n.next;//让上一个节点指向的下一个节点为当前节点指向的下一个节点
    	            count = 0;//将计数归0
    	            n = n.next;//将下个节点改为当前节点
    	        }else{//如果报数不是指定的数
    	            before = n;//当前节点就会变成上个节点
    	            n = n.next;//而下个节点则为当前节点
    	        }
    	    }
    	    return n.data;//计数到最后剩下的节点数据
    	}
    //创建节点
        private static class Node<T>{
            T data;//节点的数据
            Node next;//下个节点
            public Node(T data, Node next){
                this.data = data;
                this.next = next;
            }
        }
    }
    

    从这片风景走过,请带走属于你的风景.

    展开全文
  • 怎么把这个约瑟夫单向循环链表改写成双向循环链表。。。。。 我自己改了好久,都没有成功! 学艺不精啊!! //1.3 约瑟夫生者死者游戏 #include<stdio.h> #include<stdlib.h> typedef struct ...
  • 创建循环链表 LinkedNode head = new LinkedNode(0); LinkedNode temp = head; for (int i = 1; i ; i++) { LinkedNode newNode = new LinkedNode(i); temp.next = newNode; newNode.next = head; temp = temp.next;...

    题目:

    0,1,n-1 这 n 个数字排成一个圆圈,从数字start 开始,每次从这个圆圈里删除第 step个数字。求出这个圆圈里剩下的最后一个数字。

    例如

    0、1、2、3、4、5、6、7、8、9、10 这 11 个数字组成一个圆圈,从数字 2开始每次删除第 3 个数字,则删除的数字依次是

    输入: 10 2 3
    输出:8

    删除的第:1个节点为4
    删除的第:2个节点为7
    删除的第:3个节点为10
    删除的第:4个节点为2
    删除的第:5个节点为6
    删除的第:6个节点为0
    删除的第:7个节点为5
    删除的第:8个节点为1
    删除的第:9个节点为9
    删除的第:10个节点为3
    最后一个节点为8

    public class Main62
    {
        public static int i = 1;
        private static void yuesefucicle(int n, int start, int step)
        {
            //1.创建循环链表
            LinkedNode head = new LinkedNode(0);
            LinkedNode temp = head;
            for (int i = 1; i <= n; i++)
            {
                LinkedNode newNode = new LinkedNode(i);
                temp.next = newNode;
                newNode.next = head;
                temp = temp.next;
            }
            //2.根据start移动head和temp指针,移动start次
            int index = 0;
            while (index++ < start){
                head = head.next;
                temp = temp.next;
            }
            //上述初始化工作完成,开始剔
            while (head != temp){//只剩一个节点
                //3.移动步长step次两个指针
                index = 0;
                while (index++ < step-1){
                    head = head.next;
                    temp = temp.next;
                }
                //4.删除节点
                System.out.println("删除的第:"+i+ "个节点为"+head.val);
                i++;
                head = head.next;
                temp.next = head;
            }
            System.out.println("最后一个数为"+head.val);
        }
    
        public static void main(String[] args)
        {
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();//0->n个人
            int start = sc.nextInt();//从某个数字开始
            int step = sc.nextInt();//每隔step个数字踢出去一个
            yuesefucicle(n,start,step);
        }
    }
    class LinkedNode
    {
        public Integer val;
        public LinkedNode(Integer val)
        {
            this.val = val;
        }
        public LinkedNode next;
    }
    
    
    展开全文
  • 循环链表解决约瑟夫循环问题循环链表什么是循环链表约瑟夫循环问题循环链表解决约瑟夫循环问题C++实现运行效果 循环链表 最近开始复习数据结构,今天手写了一个约瑟夫循环问题。 什么是循环链表 首尾相连的链表:...

    循环链表

    最近开始复习数据结构,今天手写了一个约瑟夫循环问题。

    什么是循环链表

    循环链表

    首尾相连的链表:head->last=tail;tail->next=head
    建立循环链表和建立普通链表方法差不多,只需要首尾相连即可

    约瑟夫循环问题

    已知 n 个人(以编号1,2,3,…,n分别表示)围坐在一张圆桌周围,从编号为 k 的人开始顺时针报数,数到 m 的那个人出列;他的下一个人又从 1 还是顺时针开始报数,数到 m 的那个人又出列;依次重复下去,要求找到最后出列的那个人。
    例如:5个人,编号依次为12345,从第3个人开始报数,报到2的退出,然后下一个接着从开始报数
    那么退出的顺序是:4-1-3-2-5

    循环链表解决约瑟夫循环问题

    思路:从第k个节点开始,将第m-1个节点释放,连接好链表即可。

    C++实现

    
    #include<iostream>
    #include<cstdlib>
    using namespace std;
    #include<string>
    struct list {
    	struct list* next;
    	struct list* last;
    	int data;//编号
    };
    struct list* creat(int n)//创建循环链表
    {
    	struct list* head,*tail,*normal;
    	head = new list;
    	tail = new list;
    	head = tail;//不需要这一句
    	cout << "请输入数据" << endl;//头结点的数据
    	cin >> head->data;
    	for (int i = 1; i < n; i++)
    	{
    		normal = new list;
    		cout << "请输入数据" << endl;
    		cin >> normal->data;
    		tail->next = normal;//尾节点连接新创建的节点
    		normal->last = tail;//新创建的节点的上一个是尾节点
    		tail = normal;//将尾节点移动到新创建的节点
    	}
    	head->last = tail;//首尾相连
    	tail->next = head;//首尾相连
    	return head;
    }
    void delPerson(struct list* p) {//功能函数
    	struct list* head, * tail;//不需要用到head,后面的head都可以省去
    	head = new list;
    	tail = new list;
    	head = p;
    	int k;
    	cout << "请输入K" << endl;
    	cin >> k;
    	while (p->data != k)//从第k个人开始报数
    	{
    		tail = p;
    		p = p->next;
    	}
    	cout << "请输入m" << endl;
    	int m;
    	int i = 0;
    	cin >> m;
    	while (tail->next != tail)//如果不是只剩最后一个节点
    	{
    		for (i = 0; i < m-1; i++)
    		{
    			tail = p;
    			p = p->next;
    		}
    		tail->next = p->next;//tail的next连接p的next
    		p->next->last = tail;//p的下一个的上一个是tail
    		cout << "删除的编号是:" << p->data << endl;
    		free(p);//释放p
    		p = tail->next;//p移动到tail的next
    	}
    	cout << "删除的编号是:" << tail->data<<"\n";
    }
    int main()
    {
    	struct list* p;
    	p = new list;
    	int n;
    	cout << "请输入总人数" << endl;
    	cin >> n;
    	p = creat(n);
    	delPerson(p);
    	system("pause");
    	return 0;
    }
    

    运行效果

    运行结果

    展开全文
  • 约瑟夫问题循环链表实现代码
  • 约瑟夫 java 循环链表实现参考JDK链表的写法实现的,写的挺简单的,没有优化,将就看下,一起学习! 参考JDK链表的写法实现的,写的挺简单的,没有优化,将就看下,一起学习! package com.zzp.securingweb; ...

    参考JDK链表的写法实现的,写的挺简单的,没有优化,将就看下,一起学习!

    package com.zzp.securingweb;
    
    
    import java.util.NoSuchElementException;
    
    public class YuesefuMain {
        public static void main(String[] args) {
            MyList<Integer> myList = new MyList<>();
            for(int i=1;i<=7;i++){
                myList.add(i);
            }
            //报数号,剩余人数
            //报数号必须大于1 ;剩余人数必须大于0和小于列表长度
            myList.kill(2,5);
            System.out.println("size "+myList.size());
            for(int i=0;i<myList.size();i++){
                System.out.println(myList.get(i));
            }
        }
    
    }
    
    class MyList<E>{
        transient MyNode<E> first;
        transient MyNode<E> last;
        transient int size=0;
        public void add(E e){
            if(first==null){
                first = new MyNode<E>(e,null,null);
                last = first;
            }else{
                final MyNode<E> prelast = last;
                final MyNode<E> newLast = new MyNode<E>(e,prelast,first);
                if(prelast.pre == null){
                    prelast.pre = first;
                }
                if(first.next==null){
                    first.next = newLast;
                }
                first.pre = newLast;
                prelast.next = newLast;
                last = newLast;
            }
            size++;
        }
    
        public void kill(int killIndex,int left){
            if(killIndex==0){
                throw new NoSuchElementException();
            }
            if(size==0){
                throw new NoSuchElementException();
            }
            if(left<0 || left>size){
                throw new NoSuchElementException();
            }
            if(left==size)
                return;
    
            int index = killIndex%size;
            if (index==0)
                index = size;
            while(true){
                remove(index-1);
                index = killIndex%size;
                if (index==0)
                    index = size;
                if(size<=left)
                    break;
    
            }
    
        }
    
        public int size(){
            return size;
        }
    
        public E get(int index){
            if(index<0 || index>=size){
                return null;
            }
            MyNode<E> target=first;
            if(index==0){
                return target.item;
            }
            for(int i=1;i<size;i++){
                target = target.next;
                if(i==index){
                    return target.item;
                }
            }
            return null;
    
        }
    
        private void remove(int index){
            if(index<0 || index>=size){
                throw new NoSuchElementException();
            }
            MyNode<E> target=first;
            if(index==0){
                final MyNode<E> newFirst = target.next;
                first = newFirst;
                newFirst.pre = last;
            }else{
                for(int i=1;i<size;i++){
                    target = target.next;
                    if(i==index){
                        final MyNode<E> pre = target.pre;
                        final MyNode<E> next = target.next;
                        pre.next = next;
                        next.pre = pre;
                        first = next;
                        last = pre;
                        break;
                    }
                }
            }
            if(target!=null){
                target.pre=null;
                target.next=null;
                target.item = null;
            }
            size--;
    
        }
    
    }
    
    class MyNode<E> {
        E item;
        MyNode<E> next;
        MyNode<E> pre;
    
        MyNode(E element, MyNode<E> pre, MyNode<E> next) {
            this.item = element;
            this.next = next;
            this.pre = pre;
        }
    }
    
    展开全文
  • 这是用循环链表编写的约瑟夫问题,用文件头将循环链表写好了 这是用循环链表编写的约瑟夫问题,用文件头将循环链表写好了 这是用循环链表编写的约瑟夫问题,用文件头将循环链表写好了
  • 约瑟夫循环链表

    2017-11-20 23:14:37
    约瑟夫环问题的一种描述是:编号为1,2,3,n的n个人按顺时针围坐一圈,每人持有一个密码(正整数),一开始任选一个正整数作为报数上限值m,从第一个人开始按顺时针方向自1开始报数,报到m时停止报数,报m的人出列,将...
  • 这是作者在数据结构课程学习过程中,在链表学习部分的一个小小作品
  • 2在约瑟夫循环中应为出去的位置是position-1而出去了之后紧接着原来的元素位置被后面一个元素补上,所以position—1的位置 #include #include "Node.h" #include "SimpleCircLinkList.h" using namespace std; ...
  • 简单的循环链表,c语言编写,希望多多支持
  • 约瑟夫环的循环链表

    2011-11-19 20:00:00
    约瑟夫环的循环链表 附一组测试数据:3172684 20 6147235
  • 静态循环链表 struct node{ int flag; int next; }arr[11]; #include"stdio.h" #include"stdlib.h" #include"s.h" main(){ int i,j,k; for(i=0;i11;i++){ arr[i].flag =1; arr[i].nex
  • //返回循环链表第一个节点 } void PrintLinklist(LNode *head) { LNode *p,*q; p=head; while(p->next != p) { for(int i=1;i;i++) //找到删除的前驱节点 { p=p->next; } printf("%d-->",p->next...
  • 循环链表约瑟夫

    2016-11-12 20:55:13
    利用循环链表约瑟夫环问题
  • 问题描述 传说有这样一个故事,在罗马人占领乔塔帕特后,39个犹太人与约瑟夫及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一...要解决这个问题,我们先来了解一下循环链表循环链表
  • 约瑟夫问题之单链循环链表.doc
  • 约瑟夫问题循环链表实现

    千次阅读 2017-03-09 15:08:37
    、n,要求从1号从1开始报数,报到k的人出圈,接着下一个人又从1开始报数,如此循环,直到只剩最后一个人时,该人即为胜利者。例如当n=10,k=4时,依次出列的人分别为4、8、2、7、3、10,9、1、6、5,则5号位置的人为...
  • 约瑟夫求生最初版本: 在罗马人占领乔塔帕特后,39 个犹太人与Josephus及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一个自杀方式,41个人排成一个圆圈,由第1个人开始报数,每报数到...
  • 约瑟夫环(约瑟夫问题)是一个数学的应用问题:已知n个人(以编号1,2,3…n分别表示)围坐在一张圆桌周围。从编号为k的人开始报数,数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人又出列;依此规律...
  •  /*打印链表,并检查循环链表是不输入正确*/ for(i=1;i { for(j=1;j { r=p; p=p->next; } printf("出局人:%d\n",p->data); r->next=p->next; } } void main() { int x, z; printf("请输入总人数:"); scanf("%d",&...
  • 约瑟夫问题——循环链表C++

    千次阅读 2017-06-03 10:11:12
    什么是约瑟夫问题? 约瑟夫问题是一个有名的问题,编号为1-N的N个人安顺时针围坐一圈,选取M为报数的上限...区别在于循环链表的最后一个节点的指针指向该循环链表的第一个节点或头结点,从而形成一个环。在建立一个
  • 循环链表约瑟夫循环链表的实现 单链表只有向后结点,当单链表的尾链表不指向NULL,而是指向头结点时候,形成了一个环,成为单循环链表,简称循环链表。当它是空表,向后结点就只想了自己,这也是它与单链表的...
  •  3 //约瑟夫环的实现:一群人围成一圈,这群人共有 n个人,每个人身上都一个key,依次给这圈人编号:  4 //1,2,n 一开始报数的上限值为m从第一个人(编号:1)自一开始报数报到m时停止报数,报到m的人出列...
  • 1顺序建立循环链表+循环链表中的符合题意的元素结点的删除 2注意只有一个人玩死亡游戏的情况sdut原题链接约瑟夫问题 Time Limit: 1000MS Memory Limit: 65536KBProblem Description n个人想玩残酷的死亡游戏,...
  • 约瑟夫问题(10分) 题目内容:有n只猴子,按顺时针方向围成一圈选大王(编号从1到n),从第1号开始报数,一直数到m,数到m的猴子退出圈外,剩下的猴子再接着从1开始报数。就这样,直到圈内只剩下一只猴子时,这个...

空空如也

空空如也

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

约瑟夫循环链表