指针与链表练习
C程序设计(链表)习题与答案
一、单选题1、链表不具有的特点是（）。
A.不必事先估计存储空间B.插入、删除不需要移动元素C.可随机访问任一元素D.所需空间与线性表长度成正比正确答案：C2、链接存储的存储结构所占存储空间（）。
A.分两部分，一部分存放结点值，另一部分存放结点所占单元数B.只有一部分，存放结点值C.分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针D.只有一部分，存储表示结点间关系的指针正确答案：C3、链表是一种采用（）存储结构存储的线性表。
A.网状B.星式C.链式D.顺序正确答案：C4、有以下结构体说明和变量的定义，且指针p指向变量a，指针q指向变量b，则不能把结点b连接到结点a之后的语句是（）。
struct node {char data;struct node *next;} a,b,*p=&a,*q=&b;A.(*p).next=q;B.p.next=&b;C.a.next=q;D.p->next=&b;正确答案：B5、下面程序执行后的输出结果是（）。
#include <stdio.h>#include <stdlib.h>struct NODE {int num; struct NODE *next;};int main(){ struct NODE *p,*q,*r;p=(struct NODE*)malloc(sizeof(struct NODE));q=(struct NODE*)malloc(sizeof(struct NODE));r=(struct NODE*)malloc(sizeof(struct NODE));p->num=10; q->num=20; r->num=30;p->next=q;q->next=r;printf("%d",p->num+q->next->num);return 0;}A.30B.40C.10D.20正确答案：B6、下面程序执行后的输出结果是（）。
链表的经典习题
链表的经典习题练习1•：链式栈//链式栈(top指向第⼀位⽆效的头结点)public class LinkedStack<E> {Node<E> top;//内部类class Node<E> {protected E data;protected Node<E> next;public Node(E data) {this.data = data;}}public LinkedStack() {top = new Node(new Object());}//头插法public void push(E val){Node<E> newNode=new Node(val) ;//创建⼀个值为val的节点newNode.next=top.next; //新插⼊节点的next指向原top指向的nexttop.next=newNode;//再把top.next指向新节点}//获取栈顶元素并删除public E remove(){if(top.next==null){throw new UnsupportedOperationException("the stack has been empty");}E result=top.next.data;top.next=top.next.next;return result;}public E peek(){if(top.next==null){throw new UnsupportedOperationException("the stack has been empty");}return top.next.data;}//从top节点的下⼀个开始遍历，不为空则⼀直的打印public void show(){Node<E> tmp=top.next;while (tmp!=null){System.out.print(tmp.data+" ");tmp=tmp.next;}System.out.println();}public static void main(String[] args) {LinkedStack<Integer> l=new LinkedStack();l.push(3);l.push(4);l.push(5);l.show();System.out.println(l.peek());l.remove();//删除5l.show();l.remove();//删除4l.show();l.remove();//删除3l.show();}}练习2：查找链表中倒数第k个节点//单链表查找倒数第k个节点class FindLastK<E> {Node<E> head;class Node<E> {protected E data;protected Node<E> next;public Node(E data,Node<E> next) {this.data = data;this.next=next;}}////构造函数,第⼀个头结点有效，所以不需要构造函数// public FindLastK() {// this.head = new Node(new Object(),null);// }//找倒数第k个数的⽅法public E lastK(int k){Node<E> cur1=this.head.next;Node<E> cur2=this.head;//cur2指向头if(head==null){return null;}if(k>getLenth()||k<=0){return null;}else if(k==getLenth()){return head.data;}for(int i=1;i<=k;i++) {cur2=cur2.next;if(cur2==null){return null;}}while (cur2.next!=null){cur2=cur2.next;cur1=cur1.next;}return cur1.data;}//获取链表长度public int getLenth(){int length=0;Node<E> cu=head;if(head==null){return 0;}while (cu!=null){ //应该让cur去遍历，不能让head直接遍历，否则打印⼀次后show再次打印链表就会空 length++;cu=cu.next;}return length;}//尾插法public void add(E val) {Node<E> newNode = new Node(val,null);Node<E> current = head;if(head==null){head=newNode;return;}while (current.next != null) {current = current.next;}current.next = newNode;// newNode.next=null;}public void show() {Node<E> current = head;if(current==null){System.out.println("链表空！！");return;}while (current!=null&¤t.next!= null) {System.out.print(current.data + " ");current = current.next;}System.out.println(current.data);}}public class FindLastKTest{public static void main(String[] args) {FindLastK<Integer> f=new FindLastK<>();f.add(3);f.add(4);f.add(5);f.add(6);f.show();System.out.println("该链表的长度："+f.getLenth());System.out.println(stK(1));//6System.out.println(stK(4));//3System.out.println(stK(5));//nullf.show();}}练习3：找到带环链表的⼊⼝节点import sun.awt.image.ImageWatched;//单链表查找倒数第k个节点public class LinkedExercise<E> {Node<E> head;static class Node<E> {protected E data;public Node<E> next;public Node(E data, Node<E> next) {this.data = data;this.next = next;}}////构造函数,第⼀个头结点有效，所以不需要构造函数// public FindLastK() {// this.head = new Node(new Object(),null);// }//找倒数第k个数的⽅法public E lastK(int k) {Node<E> cur1 = this.head.next;Node<E> cur2 = this.head;//cur2指向头if (head == null) {return null;} else if (k > getLenth() || k <= 0) {return null;}//如果找的倒数第k个恰好为链表长度，直接将头结点的数返回else if (k == getLenth()) {return head.data;}for (int i = 1; i <= k; i++) {cur2 = cur2.next;if (cur2 == null) {return null;}}//两个节点同时遍历，快节点遍历到最后⼀个节点时，慢节点指向的节点就是要找的节点while (cur2.next != null) {cur2 = cur2.next;cur1 = cur1.next;}return cur1.data;}//获取链表长度public int getLenth() {int length = 0;Node<E> cu = head;if (head == null) {return 0;}while (cu != null) { //应该让cur去遍历，不能让head直接遍历，否则打印⼀次后show再次打印链表就会空 length++;cu = cu.next;}return length;}//判断单链表是否有环/*** 快慢指针，先通过两个指针找到环内的节点，然后再⼀个节点从相交节点出发，* 另⼀个节点从头结点出发，再次相交的节点就是环的⼊⼝节点** @return*/public E getLinkCirclrVal() {Node<E> slow = this.head;Node<E> fast = this.head;//找到了相交节点while (fast != null && fast.next != null) {slow = slow.next;fast = fast.next.next;if (slow == fast) {break;}}if (fast == null) {return null;} else {fast = this.head;while (fast != slow) {fast = fast.next;slow = slow.next;}return slow.data;}}//尾插法public void add(E val) {Node<E> newNode = new Node(val, null);Node<E> current = head;if (head == null) {head = newNode;return;}while (current.next != null) {current = current.next;}current.next = newNode;// newNode.next=null;}public void show() {Node<E> current = head;if (current == null) {System.out.println("链表空！！");return;}while (current != null && current.next != null) {System.out.print(current.data + " ");current = current.next;}System.out.println(current.data);}//构造带环的链表public void con(LinkedExercise<E> link){//将两个节点都指向头LinkedExercise.Node list=link.head;LinkedExercise.Node p=link.head;//list遍历到最后⼀个节点while (list.next!=null){list=list.next;}//让最后⼀个节点的写⼀个指向头结点的下⼀个 6指向5list.next=p.next.next;}public static void main(String[] args) {LinkedExercise<Integer> f = new LinkedExercise<>();f.add(3);f.add(4);f.add(5);f.add(6);f.show();System.out.println("该链表的长度：" + f.getLenth());System.out.println(stK(1));//6System.out.println(stK(4));//3System.out.println(stK(5));//nullf.con(f);System.out.println("环的⼊⼝节点："+f.getLinkCirclrVal());}}练习4：合并两个有序的链表（头结点⽆效时）包含头结点⽆效的⼤多数函数：class SingleLinekdListTakeHead<E extends Comparable> {protected Node<E> head;//头节点class Node<E> {protected E data;//数据域protected Node<E> next;//next引⽤域public Node(E data, Node<E> next) {this.data = data;this.next = next;}}//初始化headpublic SingleLinekdListTakeHead() {head = new Node(new Object(), null);}//在head之后直接插⼊⼀个节点，头插法public void addHead(E element) {Node<E> newNode = new Node(element, null);newNode.next = head.next;//先让新添加的节点的下⼀个指向原head节点指向的 head.next = newNode;//再让head节点指向新节点}//尾插法public void addTail(E element) {Node<E> newNode = new Node(element, null);Node<E> tail = head;//定义⼀个节点从头⾛到尾//tail⾛到当前链表的尾部while (tail.next != null) {tail = tail.next;}tail.next = newNode;newNode.next=null;}/*** 固定位置插⼊⼀个节点* 判断参数合法性* 找到pos位置的前⼀个节点* @param pos 固定位置* @param element 元素*/public void addPos(int pos, E element) {if (pos <= 0 || pos > getLength()) {return;}Node<E> prev = head.next;int index = 1;while (index++ < pos - 1) {prev = prev.next;}Node<E> newNode = new Node<>(element, null);newNode.next = prev.next;prev.next = newNode;}//删除元素为element的节点public boolean remove(E element) {//如果只有⼀个头结点，返回falseif (head.next == null) {return false;}//找到该元素所对应的节点 + 该元素所对应的节点的前⼀个 //从头结点开始遍历Node<E> tmp = head;while (tmp != null) {if (tmp.next != null && tmp.next.data == element) {//tmp.next是我们要删除的节点 tmp是删除节点的前⼀个 tmp.next = tmp.next.next;return true;}tmp = tmp.next;}return false;}//设置某个位置的值为newElementpublic void set(int pos, E newElement){if(pos <= 0 || pos > getLength()){return;}//找pos位置的节点Node<E> tmp = head.next;for(int i=1; i < pos; i++){tmp = tmp.next;}tmp.data = newElement;}//得到某个元素的值public E get(E element){Node<E> tmp = head.next;//从有效节点开始遍历while(tmp != null){if(tmp.data == element){return tmp.data; //找到的话，返回该节点}tmp = tmp.next;}return null;} //合并两个有序的单链表public void merge(SingleLinekdListTakeHead<E> list2){// LinkedExercise<E> list3=new LinkedExercise<>();Node<E> p=this.head;//最后合并成功的的链表Node<E> p1=this.head.next;//第⼀的链表Node<E> p2=list2.head.next;//第⼆个链表while (p1!=null && p2!=null){if(pareTo(p2.data)>=0){p.next=p2;//list3.add(p2.data);p2=p2.next;}else {p.next=p1;// list3.add(p1.data);p1=p1.next;}p=p.next;}if(p1!=null){ //链表1还有剩余节点p.next=p1;}p.next=p2;}// return p.data;}//返回长度public int getLength() {Node<E> tmp = head.next;int length = 0;while (tmp != null) {length++;tmp = tmp.next;}return length;}//打印栈public String toString() {StringBuilder strs = new StringBuilder();Node<E> tmp = head.next;while (tmp != null) {strs.append(tmp.data + " ");tmp = tmp.next;}return strs.toString(); //strs是StringBuilder类型，应该添加toString⽅法，才能返回String类型的 }//逆置带有头结点的单链表public void reverse(){if(head.next==null||head.next.next==null){return;}else {Node<E> cur=this.head.next.next;//指向第⼆个有效的节点this.head.next.next=null;Node<E> pos=null;while (cur!=null){pos=cur.next;//先将cur.next指向poscur.next=head.next;head.next=cur;//头插法，将节点插在head后cur=pos;}}}}public class Linked {public static void main(String[] args) {SingleLinekdListTakeHead<Integer> list=new SingleLinekdListTakeHead();list.addHead(3);list.addHead(5);list.addHead(8);System.out.println(list.toString());//8 5 3list.addTail(1);list.addTail(2);list.addTail(4);System.out.println(list.toString());//8 5 3 1 2 4list.reverse();System.out.println(list.toString());// list.addPos(2, 100); //在2 号位置加⼊元素100// System.out.println(list.toString());// list.addPos(0, 1000);// System.out.println(list.toString());//// list.remove(4);// System.out.println("删除值为4的元素:"+list.toString());//// list.set(2,2);//true,把2号元素的值改为2// System.out.println("把2号元素的值改为2:"+list.toString());// System.out.println(list.get(3));SingleLinekdListTakeHead list1=new SingleLinekdListTakeHead();list1.addTail(2);list1.addTail(6);list1.addTail(7);SingleLinekdListTakeHead list2=new SingleLinekdListTakeHead();list2.addTail(3);list2.addTail(4);list2.addTail(5);list2.addTail(9);list2.addTail(10);list1.merge(list2);System.out.println(list1.toString());}}练习5：链式队列package Exercise;public class LinkedQueue<T> {private Entry<T> front;private Entry<T> rear;private int count;public LinkedQueue(){this.front=this.rear=new Entry<>(null,null);}class Entry<T>{T data;Entry<T> next;public Entry(T data,Entry<T> next){this.data=data;this.next=next;}}public void offer(T data){Entry<T> node=new Entry<>(data,null);this.rear.next=node;this.rear=node;this.count++;}/***出队列需要判断队列空的情况，头节点⽆效；如果队列为空，需要将front和rear都指向空*/public void poll(){if(this.front.next!=null){this.front.next=this.front.next.next;if(this.front.next == null){this.rear = this.front;}this.count--;}}public int size(){return this.count;}public T peek(){return this.front.next.data;}public void show(){Entry<T> cur=this.front.next;while (cur!=null){System.out.print(cur.data+" ");cur=cur.next;}System.out.println();}public static void main(String[] args) {LinkedQueue l=new LinkedQueue();for (int i = 0; i < 4; i++) {l.offer(i);}l.show();System.out.println("队头元素为:"+l.peek());System.out.println("队列长度为："+l.size());l.poll();l.show();}}难点：内部类和外部类的构造函数都需要对相应属性做初始化。
数据结构单元4练习参考答案
单元测验4一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳）（√）（1）队列是限制在两端进行操作的线性表。
（√）（2）判断顺序队列为空的标准是头指针和尾指针都指向同一个结点。
（×）（3）在链队列上做出队操作时，会改变front指针的值。
（√）（4）在循环队列中，若尾指针rear大于头指针front，其元素个数为rear- front。
（×）（5）在单向循环链表中，若头指针为h，那么p所指结点为尾结点的条件是p=h。
（√）（6）链队列在一定范围内不会出现队满的情况。
（×）（7）在循环链队列中无溢出现象。
（×）（8）栈和队列都是顺序存储的线性结构。
（×）（9）在队列中允许删除的一端称为队尾。
（×）（10）顺序队和循环队关于队满和队空的判断条件是一样的。
二．填空题（1）在队列中存取数据应遵循的原则是先进先出。
（2）队列是被限定为只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表。
（3）在队列中，允许插入的一端称为队尾。
（4）在队列中，允许删除的一端称为队首（或队头）。
（5）队列在进行出队操作时，首先要判断队列是否为空。
（6）顺序队列在进行入队操作时，首先要判断队列是否为满。
（7）顺序队列初始化后，front=rear= -1 。
（8）解决顺序队列“假溢出”的方法是采用循环队列。
（9）循环队列的队首指针为front，队尾指针为rear，则队空的条件为 front == rear 。
（10）链队列LQ为空时，LQ->front->next= NULL 。
（11）设长度为n的链队列用单循环链表表示，若只设头指针，则入队操作的时间复杂度为 O（n）。
（12）设长度为n的链队列用单循环链表表示，若只设尾指针，则出队操作的时间复杂度为 0（1）。
（13）在一个链队列中，若队首指针与队尾指针的值相同，则表示该队列为空。
（14）设循环队列的头指针front指向队首元素，尾指针rear指向队尾元素后的一个空闲元素，队列的最大空间为MAXLEN，则队满标志为：front==(rear+1)%MAXLEN 。
第08章指针和链表真题
历年真题（指针）一、2003年1月10.以下定义语句中，错误的是（A ） int a{}={1,2}; （B ） char *a[3];（C ） char s[10]=”text ”; （D ） int n=5,a[n];14.下列语句执行后的结果是 。
y=5;p=&y;x=*p++;（A ）x=5，y=5 （B ）x=5，y=6（C ）x=6，y=5 （D ）x=6，y=615. 执行下面的语句后，表达式*(p[0]+1)+**(q+2)的值为 。
int a[]={5,4,3,2,1};*p[]={a+3,a+2,a+1,a};**q=p;（A ）8 （B ）7 （C ）6 （D ）516. 经过下面的语句int I,a[10],*p;定义后，下列语句中合法的是 。
（A ）p=100; （B ）p=a[5];（C ）p=a+2; （D ）p=&(i+2);29. 有如下程序main(){ char ch[2][5]={“6937”, “8254”},*p[2];int i,j,s=0;for(i=0;i<2;i++) p[i]=ch[i];for(i=0;i<2;i++)for(j=0;p[i][j]>‟0‟;j+=2)s=10*s+p[i][j]-…0‟;printf(“%d\n ”,s);}该程序的输出结果是 。
（A ）69825 （B ）63825 （C ）6385 （D ）69382530. 若建立如下图所示的单项链表结构date nextheadS在该链表结构中，指针p ，s 分别指向图中所示节点，则不能将s 所指的节点插入链表末尾仍构成单向链表的语句组是 。
（A ） p=p->next;s->next=p;p->next=s;（B）p=p->next;s->next=p->next;p->next=s;（C）s->next=NULL;p =p->next;p->next=s;（D）p=(*p).next;(*s).next=(*p).next; (*p).next=s;试卷二试题二：把下列程序补充完整实现两个字符串的比较，即自己写个strcmp函数，函数原型为：int strcmp(char *p1,char *p2)设p1指向字符串s1，p2指向字符串s2，要求：当s1=s2时，返回值为0。
数据结构链表习题
练习题：1）在一个单链表head中，若要在指针p所指结点后插入一个q指针所指结点，则执行_____。
A. p->next=q->next; q->next=p;B. q->next=p->next; p=q;C. p->next=q->next; p->next=q;D. q->next=p->next; p->next=q;2）在一个单链表head中，若要删除指针p所指结点的后继结点，则执行_____。
A. p=p->next;free(p);B. p->next=p->next->next; free(p);C. q= p->next ;q->next=p->next; free(q);D. q=p->next; p->next=q->next ;free(q);3）若长度为n的线性表(a1, a2,…, a n)采用顺序存储，在第i个位置上插入一个新元素，需要依次向后移动个数据元素。
A n-iB n-i-1C n-i+1D n+i3）完成下列打印带头单链表的各元素的算法.typedef struct List{ int data;struct List *next;} Node，*Link;void printlk(Link head){Link p=head->next;{ printf(“%d\n”,p->data);}4）已知无头单链表A和B表示两个集合，本算法实现A=A-B (集合的补运算)。
typedef struct node {int data;struct node *next;}lnode;void setminus(lnode *&A,lnode *B)while (B!=NULL){p=A;}A=A->next;}5）下列算法创建n个元素的带头单链表.typedef struct lnode { int data;struct lnode *next;}lnode,*linklist ;void create(linklist &head, int n){linklist p; int i;head=(linklist)malloc(sizeof(lnode));A head->next=nullfor(i=n;i>0;i--){p =(linklist)malloc(sizeof(lnode));scanf(“%d”,&p->data);B p->next=head->nextC head->next=p}}。
课堂练习题---链表
1、设单链表中指针P指着结点A ，若要删除A之后结点（若存在），则需要修改指针的操作为（）。
A. p->next=p->next->nextB. p=p->nextC. p=p->next->nextD. P->next=p８.从一个具有n个节点的单链表中查找其值等于x结点时，在查找成功的情况下，需平均比较个结点。
A. nB. n/2C. (n-1)/2D. (n+1)/22.在一个单链表中，已知*q结点是*p结点的前驱结点，若在*q和*p之间插入*s 结点，则执行。
A. s->next=p->next; p->next=s;B. p->next=s->next; s->next=p;C. q->next=s; s->next=p;D. p->next=s; s->next=q;3.线性表采用链式存储时，其地址。
A. 必须是连续的B.部分地址必须是连续的C. 一定是不连续的D. 连续与否均可以4.设单链表中指针p指着结点(数据域为m)，指针f指着将要插入的新结点(数据域为x)，当x插在结点m之后时，只要先修改后修改p->link=f即可。
A. f->link=p;B. f->link=p->link;C. p->link=f->link;D. f=nil;5.在双向链表存储结构中，删除p所指的结点时需修改指针。
A. ((p->rlink) ->rlink) ->link=p; p->rlink=(p->rlink) ->rlink;B. (p->llink) ->rlink=p->rlink; (p->rlink) ->llink=p->llink;C. p->llink=(p->llink) ->llink; ((p->llink) ->llink) ->rlink=p;D. ((p->llink) ->llink) ->rlink=p; p->llink=(p->llink) ->llink;6.在双向链表存储结构中，删除p所指的结点的前趋结点（若存在）时需修改指针。
链表
第二章习题填空题1．当线性表的元素总数基本稳定，且很少进行插入和删除操作，但要求以最快的速度存取线性表中的元素时,应采用_______存储结构。
2．线性表L=（a1,a2,…,an）用数组表示，假定删除表中任一元素的概率相同，则删除一个元素平均需要移动元素的个数是________。
3．设单链表的结点结构为(data,next)，next为指针域，已知指针px指向单链表中data为x的结点，指针py指向data为y的新结点 , 若将结点y插入结点x之后，则需要执行以下语句:_______； ______;4．在一个长度为n的顺序表中第i个元素（1<=i<=n）之前插入一个元素时，需向后移动________个元素。
5．在单链表中设置头结点的作用是________。
6．对于一个具有n个结点的单链表，在已知的结点*p后插入一个新结点的时间复杂度为________,在给定值为x的结点后插入一个新结点的时间复杂度为________。
7．根据线性表的链式存储结构中每一个结点包含的指针个数，将线性链表分成________和_______；而又根据指针的连接方式，链表又可分成________和________。
8．在双向循环链表中,向p所指的结点之后插入指针f所指的结点，其操作是_______、_______、 _______、________。
9．在双向链表结构中，若要求在p 指针所指的结点之前插入指针为s 所指的结点，则需执行下列语句：s^ ．next:=p； s^ ．prior:= ________；p^ ．prior:=s；________:=s；10．链接存储的特点是利用________来表示数据元素之间的逻辑关系。
11．顺序存储结构是通过________表示元素之间的关系的;链式存储结构是通过________表示元素之间的关系的。
12．对于双向链表,在两个结点之间插入一个新结点需修改的指针共 ______个，单链表为_______个。
链表概念及其表示经典练习题
链表概念及其表示经典练习题
链表是计算机中常用的一种数据结构，它由若干个节点组成，
每个节点包含数据和指向下一个节点的指针。
链表分为单向链表、
双向链表和循环链表。
单向链表
单向链表中，每个节点只有一个指向下一个节点的指针，最后
一个节点的指针指向空地址。
单向链表的插入和删除操作比较简单，但是查找操作需要从头节点开始遍历。
练题
1. 实现单向链表的创建、插入、删除和遍历操作。
2. 反转单向链表。
3. 查找单向链表中倒数第k个节点。
双向链表
双向链表中，每个节点有两个指针，一个指向前一个节点，一个指向下一个节点。
双向链表的插入和删除操作比单向链表更加灵活，但是需要对前后节点的指针进行操作。
练题
1. 实现双向链表的创建、插入、删除和遍历操作。
2. 反转双向链表。
3. 查找双向链表中倒数第k个节点。
循环链表
循环链表中，最后一个节点的指针指向头节点，形成一个环。
相比于单向链表和双向链表，循环链表更加灵活，可以实现循环遍历。
练题
1. 实现循环链表的创建、插入、删除和遍历操作。
2. 反转循环链表。
3. 查找循环链表中倒数第k个节点。
以上是链表的概念及其表示，以及相应的经典练习题。
掌握这些知识，可以对链表有更深入的理解，也更利于进行编程实现。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
指针与链表练习
1、围绕着山顶有10 个洞，一只兔子和一只狐狸各住一个洞，狐狸总想吃掉兔子。
一天兔子对狐狸说，你想吃我有一个条件，第一次隔一个洞找我，第二次隔两个洞找我，以后依次类推，次数不限。
若能找到我，你就可以饱餐一顿，在没找到我之前不能停止。
狐狸一想只有10 个洞，寻找的次数又不限，哪有找不到的道理，就答应了条件。
结果就是没找着。
现请你编写一程序，假定狐狸找了1000 次，兔子躲在哪个洞里才安全。
2、输入一串大写字母，用这些字母建立一个指针链表，然后输出这个链表。
链表中可能有一些重复的字母，将重复的多余字母从链表中删除，只留下第1个，输出链表。
再将剩余链表中的字符按ASCII码升序重排，然后输出该链表。
例如：输入：DSDFRSSDFGDKAHHAUJDJG
输出：DSDFRSSDFGDKAHHAUJDJG
DSFRGKAHUJ
ADFGHJKRSU
3、约瑟夫的新问题
源程序文件名 jsf.pas
可执行文件名 jsf.exe
输入文件名 jsf.in
输出文件名 jsf.out
时间限制 1秒
问题描述
将1～Ｍ这Ｍ个自然数按由小到大的顺序沿顺时针方向围成一圈。
以Ｓ为起点，先沿顺时针方向数到第N个数就出圈，然后再沿逆时针方向数到第Ｋ个数再出圈，再沿顺时针方向数到第N个数就出圈，然后再沿逆时针方向数到第Ｋ个数再出圈，……。
这样按顺时针方向和逆时针方向不断出圈，直到全部数都出圈为止。
请打印先后出圈的数的序列。
输入格式
文件中共4行，每行为一个自然数，分别表示M，S，N，K。
M不超过1000。
输出格式
仅1行，先后出圈的数的序列，每个数之间有1个空格。
样例输入（jsf.in）
8
1
3
2
样例输出（jsf.out）
3 1 5 2 7
4 6 8
（解释：先从1开始沿顺时针方向数到3，所以3先出圈；再从2开始沿逆时针方向数到1，所以1出圈；再从2开始沿顺时针方向数到5，所以5出圈，再从4开始沿逆时针方向数到2，所以2出圈，……）
DOCUMENT
源程序名 DOCUMENT.???(PAS,C,C++)
可执行文件名 DOCUMENT.EXE
输入文件名 DOCUMENT.IN
输出文件名 DOCUMENT.OUT
时间限制 2S
Andy很喜欢旧电脑。
他喜欢任何和旧电脑有关的东西，并且他在自己现代的计算机里装着旧的操作系统。
Andy也很喜欢为旧电脑写程序。
最近他决定为他的文本模式的操作系统写一个文本编辑器。
他遇到的最困难任务是要处理文档索引。
一个文档的索引是所有在文档中出现的单词按字典顺序的排列，并且附上这些单词出现的页码。
Andy感觉他没有能力写文本编辑器的这个实现索引的组件，所以他请你帮忙。
一篇文档是一些段落的组合。
每一个段落包含一行或者多行。
段落之间以一个空行为区分。
首先这篇文档是有页码的——即分成了很多的页。
每一页最多有n行。
一页上是一行接着一行的，直到排满n行为止。
以下是分页法则：
●如果一页的最后一行是一段的最后一行，则下面的空行被忽略。
因此，没有一页
纸是由空行打头的。
●如果一页最后一行是一段的第一行，且这一段不止一行，那么这一行将被移到下
一页。
●如果一页最后一行是一段的倒数第二行，且这一段超过3行，那么这一行被移到
下一页。
●如果一页最后一行是一段的倒数第二行，且这一段只有2或3行，那么这一整段
被移到下一页。
运用这个分页法则，直到整个文档全部编号页码。
一个单词是一串英文字母。
大小写不敏感。
文档的索引包含文档中每一个单词和他们出现的位置（即页码）。
一个单词对应的页码必须按升序排列。
数字之间用逗号间隔。
如果一个单词在连续的几页中出现，则对开始的页码和最后的页码被列出来，中间用减号(-)相隔，例如“3-5,7-10,12,13,15”。
输入
在输入文件的第一行是一个整数n(4<=n<=100)。
输入文件的其他部分包含要被索引的文档。
输入文件的大小不超过20,000字节。
如果一行什么都没有则视为空行。
每行没有开始和结尾的空格。
文档不包含连续的两个空行。
文档的第一行不是空行。
每一行不超过200个字符。
输出
输出所有出现在文档中的单词。
单词必须按字典顺序列出，一个单词一行。
在每一个单词之后是一个空格，然后是页码编号，编号的格式按照题目的要求。
单词都用大写字母表示。
样例
DOCUMENT.IN
6
From thousands of teams competing in regional
contests held from September to December 2004
world-wide, seventy-five teams will advance to
the World Finals in Shanghai, April 3-7, 2005.
Awards, prizes, scholarships, and bragging rights
will be at stake for some of the world’s finest
university students of the computing science.
Join us for the challenge, camaraderie,
and the fun! Become the best of the best
of the best in ACM ICPC!
ACM ICPC is the best contest!
DOCUMENT.OUT
ACM 3
ADVANCE 1
AND 2,3
APRIL 1
AT 2
AWARDS 2
BE 2
BECOME 3
BEST 3
BRAGGING 2
CAMARADERIE 3
CHALLENGE 3
COMPETING 1
COMPUTING 2
CONTEST 3
CONTESTS 1
DECEMBER 1
FINALS 1
FINEST 2
FIVE 1
FOR 2,3
FROM 1
FUN 3
HELD 1
ICPC 3
IN 1,3
IS 3
JOIN 3
OF 1-3 PRIZES 2 REGIONAL 1 RIGHTS 2
S 2 SCHOLARSHIPS 2 SCIENCE 2 SEPTEMBER 1 SEVENTY 1 SHANGHAI 1 SOME 2
STAKE 2 STUDENTS 2 TEAMS 1
THE 1-3 THOUSANDS 1 TO 1 UNIVERSITY 2 US 3
WIDE 1
WILL 1,2 WORLD 1,2。