数据结构教程java（数据结构JAVA编程求教）

本文目录

• 数据结构JAVA编程求教
• 《数据结构与算法分析 java语言描述》这本书我连开始的级数公式都看不懂怎么办
• 数据结构（java版）
• 数据结构在java里如何实现
• JAVA数据结构
• 用一维整数数组实现数据结构中的堆栈(Stack)（用java语言）
• 数据结构 JAVA语言描述 求大神们帮补充完善
• 数据结构 停车场管理 JAVA（急！！！）
• 急..用JAVA语言实现数据结构实验！
• 高手请帮忙用java版的数据结构，设置3个队列，实现入队出队

数据结构JAVA编程求教

#include《stdio.h》 /* EOF(=^Z或F6),NULL */

#define FALSE 0

#define OK 1

#define ERROR 0

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

#define N 9 /* 数据元素个数 */

typedef char KeyType; /* 设关键字域为字符型 */

typedef struct /* 数据元素类型 */

{

  KeyType key;

  int weight;

}ElemType;

ElemType r={{’A’,1},{’B’,1},{’C’,2},{’D’,5},{’E’,3},

               {’F’,4},{’G’,4},{’H’,3},{’I’,5}}; /* 数据元素(以教科书例9-1为例),全局变量 */

int sw; /* 累计权值，全局变量 */

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)《(b))

typedef struct

{

  ElemType *elem; /* 数据元素存储空间基址，建表时按实际长度分配，0号单元留空 */

  int length; /* 表长度 */

}SSTable;

Status Creat_Seq(SSTable *ST,int n)

{ /* 操作结果: 构造一个含n个数据元素的静态顺序查找表ST(数据来自全局数组r) */

  int i;

  (*ST).elem=(ElemType *)calloc(n+1,sizeof(ElemType)); /* 动态生成n个数据元素空间(0号单元不用) */

  if(!(*ST).elem)

    return ERROR;

  for(i=1;i《=n;i++)

    *((*ST).elem+i)=r; /* 将全局数组r的值依次赋给ST */

  (*ST).length=n;

  return OK;

}

void Ascend(SSTable *ST)

{ /* 重建静态查找表为按关键字非降序排序 */

  int i,j,k;

  for(i=1;i《(*ST).length;i++)

  {

    k=i;

    (*ST).elem单元 */

    for(j=i+1;j《=(*ST).length;j++)

      if LT((*ST).elem.key)

      {

        k=j;

        (*ST).elem;

      }

    if(k!=i) /* 有更小的值则交换 */

    {

      (*ST).elem;

      (*ST).elem;

    }

  }

}

Status Creat_Ord(SSTable *ST,int n)

{ /* 操作结果: 构造一个含n个数据元素的静态按关键字非降序查找表ST */

  /* 数据来自全局数组r */

  Status f;

  f=Creat_Seq(ST,n);

  if(f)

    Ascend(ST);

  return f;

}

Status Traverse(SSTable ST,void(*Visit)(ElemType))

{ /* 初始条件: 静态查找表ST存在，Visit()是对元素操作的应用函数 */

  /* 操作结果: 按顺序对ST的每个元素调用函数Visit()一次且仅一次。 */

  /* 一旦Visit()失败，则操作失败 */

  ElemType *p;

  int i;

  p=++ST.elem; /* p指向第一个元素 */

  for(i=1;i《=ST.length;i++)

    Visit(*p++);

  return OK;

}

typedef ElemType TElemType;

typedef struct BiTNode

{

  TElemType data;

  struct BiTNode *lchild,*rchild; /* 左右孩子指针 */

}BiTNode,*BiTree;

Status SecondOptimal(BiTree *T, ElemType R,int low,int high)

{ /* 由有序表R==0)递归构造 */

  /* 次优查找树T。*/

  int i,j;

  double min,dw;

  i=low;

  min=fabs(sw);

  dw=sw;

  for(j=low+1;j《=high;++j) /* 选择最小的△Pi值 */

    if(fabs(dw-sw)《min)

    {

      i=j;

      min=fabs(dw-sw);

    }

  *T=(BiTree)malloc(sizeof(BiTNode));

  if(!*T)

    return ERROR;

  (*T)-》data=R; /* 生成结点 */

  if(i==low)

    (*T)-》lchild=NULL; /* 左子树空 */

  else

    SecondOptimal(&(*T)-》lchild,R,sw,low,i-1); /* 构造左子树 */

  if(i==high)

    (*T)-》rchild=NULL; /* 右子树空 */

  else

    SecondOptimal(&(*T)-》rchild,R,sw,i+1,high); /* 构造右子树 */

  return OK;

}

void FindSW(int sw,SSTable ST)

{ /* 按照有序表ST中各数据元素的Weight域求累计权值表sw */

  int i;

  sw=0;

  for(i=1;i《=ST.length;i++)

    sw.weight;

}

typedef BiTree SOSTree; /* 次优查找树采用二叉链表的存储结构 */

Status CreateSOSTree(SOSTree *T,SSTable ST)

{ /* 由有序表ST构造一棵次优查找树T。ST的数据元素含有权域weight。*/

  if(ST.length==0)

    *T=NULL;

  else

  {

    FindSW(sw,ST); /* 按照有序表ST中各数据元素的Weight域求累计权值表sw */

    SecondOptimal(T,ST.elem,sw,1,ST.length);

  }

  return OK;

}

Status Search_SOSTree(SOSTree *T,KeyType key)

{ /* 在次优查找树T中查找关键字等于key的元素。找到则返回OK，否则返回FALSE */

  while(*T) /* T非空 */

    if((*T)-》data.key==key)

      return OK;

    else if((*T)-》data.key》key)

      *T=(*T)-》lchild;

    else

      *T=(*T)-》rchild;

  return FALSE; /* 顺序表中不存在待查元素 */

}

void print(ElemType c) /* Traverse()调用的函数 */

{

  printf("(%c %d) ",c.key,c.weight);

}

void main()

{

  SSTable st;

  SOSTree t;

  Status i;

  KeyType s;

  Creat_Ord(&st,N); /* 由全局数组产生非降序静态查找表st */

  Traverse(st,print);

  CreateSOSTree(&t,st); /* 由有序表构造一棵次优查找树 */

  printf("\n请输入待查找的字符: ");

  scanf("%c",&s);

  i=Search_SOSTree(&t,s);

  if(i)

    printf("%c的权值是%d\n",s,t-》data.weight);

  else

    printf("表中不存在此字符\n");

}

运行结果：

这个是数据结构上的一个源码，你用这个自己改一改试试吧

《数据结构与算法分析 java语言描述》这本书我连开始的级数公式都看不懂怎么办

数据结构的书有很多，内容大同小异，都是线性表、链表、栈和队列、树、图、排序、查找等内容。只是每一部分举例子时采用的样例不同而已，级数公式看不懂没关系，也不用专门去补习高等数学，略过这个例子，看其他能看懂的，把数据结构的基本思想掌握了即可。

数据结构（java版）

package game24.datastructure.list;
/**
 * 链表的结点
 * @author luoweifu
 *
 */
class Node{
Object data;//数据元素
Node next;//后驱结点
public Node() {
this(null);
}
public Node(Object data) {
this.data = data;
this.next = null;
}
}
/**
 * 带头结点的链式链表,下标从0开始; 
 * @author Administrator
 *
 */
public class SinglyLinkedList《E》{
Node head;//头结点
int size;//链表的大小
public SinglyLinkedList() {
head = new Node();
size = 0;
}
public SinglyLinkedList(E datas) {
int n = datas.length;
head = new Node();
Node p = head;
for(int i=0; i《n; i++) {
p.next = new Node(datas);
p = p.next;
}
size = n;
}
public SinglyLinkedList(SinglyLinkedList list) {
head = list.head;
size = list.size();
}
public void add(Object e) {
Node p;
if(0 == size) {
p = head;
} else {
p = index(size-1);
}
p.next = new Node(e);
size ++;
}
public void concat(SinglyLinkedList list) {
Node lastNode = this.index(size - 1);
lastNode.next = list.index(0);
size += list.size();
}
public void clear() {
head.next = null;
size = 0;
}
public Object get(int i) {
Node p = index(i);
return p.data;
}
private Node index(int i) {
Node p = null;
if(i》=0 && i《size){
p = head;
for(int j=0; j《=i; j++) {
p = p.next;
}
} 
return p;
}
public int indexOf(Object e) {
Node p = head.next;
int i = 0;
while(!p.data.equals(e)) {
p = p.next;
i++;
}
if(i《size)
return i;
else 
return -1;
}
public void insert(int i, Object e) {
Node p = index(i);
Node p2 = new Node(e);
p2.next = p.next;
p.next = p2;
size ++;
}
public boolean isEmpty() {
if(size ==0)
return true;
else
return false;
}
public int lastIndexOf(Object e) {
int i = size-1;
while(!get(i).equals(e)) {
i--;
}
if(i》=0)
return i;
else 
return -1;
}
public void remove(int i) {
if(i》=0 && i《size) {
Node p = null;
if(i == 0)
p = head;
else {
p = index(i-1);
}
p.next = index(i).next;
}
size --;
}
public void set(int i, Object e) {
Node p = index(i);
p.data = e;
}
public int size() {
return size; 
}
@Override
public boolean equals(Object obj) {
SinglyLinkedList list = (SinglyLinkedList)obj;
if(this == obj && size == list.size) {
return true;
}
return false;
}
/**
 * 测试线性表
 * @param args
 */
public static void main(String args) {
//List list = new LinkList();
//List list = new DoubleLinkList();
SinglyLinkedList list1 = new SinglyLinkedList();
for(int i=0; i《10; i++) {
list1.add(new Integer(i));
}
Integer  a = {101, 102, 103, 104, 105, 106, 107, 108, 109, 110};
SinglyLinkedList list = new SinglyLinkedList(a);
list.remove(9);
System.out.print("size:" + list.size() + "\n");
System.out.println("isEmpty:" + list.isEmpty());
System.out.print("第7个位置的元素：" + list.get(7) + "\n");
list.concat(list1);
for(int i=0; i《list.size(); i++) {
System.out.print(list.get(i) + "    ");
}
list.add(21);
list.add(22);
list.insert(3, new Integer(5));
System.out.print("size:" + list.size() + "\n");
System.out.print("第一次出现5的索引：" + list.indexOf(5) + "\n");
System.out.print("最后一次出现5的索引：" + list.lastIndexOf(5) + "\n");
list.set(0, new Integer(30));
for(int i=0; i《list.size(); i++) {
System.out.print(list.get(i) + "    ");
}
SinglyLinkedList list2 = list;
System.out.println("\n is equels?  " + list2.equals(list));
}
}

数据结构在java里如何实现

首先Java没有指针(为了安全和方便编程).
其次数据结构和指针无关，和语言也无关.
Java封装好了各种基本的数据结构 比如:
数组,队列,Stack,HashTable,HashSet,HaspMap等等
你说的顺序表 Java中你可以用:
ArrayList 这个类:
***隐藏网址***
如果你自己想用Java裸写一个类似功能的类可以参考这个:
***隐藏网址***

JAVA数据结构

public class CallNotes {
String name;
String phoneNumber;
static Map《String,String》 noteMap=null;
static List《CallLog》 logList=null;

CallNotes(){
this.noteMap = new HashMap《String,String》();
this.logList = new ArrayList《CallLog》();
}

void addRecord(String name,String number){
noteMap.put(name,number);
}
void removeRecord(String name){
noteMap.remove(name);
}

String searchPhoneNumber(String name){
String number=null;
number = noteMap.get(name);
logList.add(new CallLog(name, number, new Date()));
return number;
}
void outputCallLog(CallLog log){
if(log==null) return ;
log.outputLog();
}

class CallLog{
String name;
String number;
Date date;
CallLog(String name,String num,Date date) {
this.name=name;
this.number=num;
this.date=date;
}
void outputLog(){
System.out.println("name:"+this.name);
System.out.println("number:"+this.number);
System.out.println("date:"+this.date);
}
}
}
用HashMap实现可以吗？

用一维整数数组实现数据结构中的堆栈(Stack)（用java语言）

public class IntStack {
private int stack;
private int top;
/**
*初始化栈，传入一个非负的整数，否则抛出一个错误
*/
public IntStack(int size) throws StackErrorException{
if(size《0){
throw new StackErrorException("错误的大小");
}
init(size);
}
private void init(int size) {
stack = new int;
top = 0;
}
/**
*判断栈是否为空，true则为空，反之则反
*/
public boolean isEmpty(){
return top==0;
}
/**
*判断栈是否已满，true则已满，反之则反
*/
public boolean isFull(){
return top==stack.length;
}
/**
*向栈顶添加元素，满则抛出异常
*/
public void push(int value) throws StackErrorException{
if(isFull()){
throw new StackErrorException("栈已满");
}
stack = value;
}
/**
*移除栈顶元素并返回，空则抛出异常
*/
public int pop() throws StackErrorException{
if(isEmpty()){
throw new StackErrorException("已到栈底!");
}
return stack;
}
/**
*返回栈顶元素，空则抛出异常
*/
public int peek() throws StackErrorException{
if(isEmpty()){
throw new StackErrorException("已在栈底!");
}
return stack;
}
/**
*返回栈大小
*/
public int size(){
return stack.length;
}
class StackErrorException extends Exception{
public StackErrorException(String msg) {
super(msg);
}
}
}

数据结构 JAVA语言描述 求大神们帮补充完善

public void nextOrder()
{
for(int i=0;i《length; i++){
if(listArray》0){//如果listArray里装的是数字，可以直接比较，如果为其他，需要将它转化为数字在比较
System.out.println(listArray.toString());
}
}
}
第二个跟上面一样

数据结构 停车场管理 JAVA（急！！！）

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Stack;
import java.util.Vector;
import java.util.regex.MatchResult;
public class Test {
private CarStop carStop = new CarStop(3);
private CarTunnel tunnel = new CarTunnel();
public void test(){
//存放车辆信息，因为不是顺序输入的，所以放到Map中
HashMap《Integer, Car》 carMap = new HashMap《Integer, Car》();
//最早进入车库的时间和最晚出车库的时间
int startTime, endTime;

startTime = Integer.MAX_VALUE;
endTime = Integer.MIN_VALUE;

Scanner scanner = new Scanner(System.in);
//("A"或者"D"或者"E", int, int)
while(scanner.hasNext("\\((A|D|E),(\\d+),(\\d+)\\)")){
scanner.next("\\((A|D|E),(\\d+),(\\d+)\\)");
MatchResult r = scanner.match();
Car car;
//如果输入A
if (r.group(1).equalsIgnoreCase("A")){
// 该车已经记录过
if (carMap.keySet().contains(Integer.parseInt(r.group(2)))){
// 取出来设置到达时间
car = carMap.get(Integer.parseInt(r.group(2)));
car.arrive = Integer.parseInt(r.group(3));
}else{
// 否则就记录该车
car = new Car(Integer.parseInt(r.group(2)), Integer.parseInt(r.group(3)));
carMap.put(car.no, car);
}
if (car.arrive 《 startTime) startTime = car.arrive;
if (car.leave 》 endTime) endTime = car.leave;
// 出库时间和到达时间同样处理
}else if (r.group(1).equalsIgnoreCase("D")){
if (carMap.keySet().contains(Integer.parseInt(r.group(2)))){
car = carMap.get(Integer.parseInt(r.group(2)));
car.leave = Integer.parseInt(r.group(3));
}else{
car = new Car(Integer.parseInt(r.group(2)), 0, Integer.parseInt(r.group(3)));
carMap.put(car.no, car);
}
if (car.arrive 《 startTime) startTime = car.arrive;
if (car.leave 》 endTime) endTime = car.leave;
}else if (r.group(1).equalsIgnoreCase("E")){
break;
}
}

// 把记录过的车做成数组并且排序
Car;
cars = carMap.values().toArray(cars);
Arrays.sort(cars, new Comparator《Car》(){
// 排序顺序是到达时间》出库时间》车牌
public int compare(Car c1, Car c2) {
if (c1.arrive!=c2.arrive) return c1.arrive - c2.arrive;
if (c1.leave!=c2.leave) return c1.leave - c2.leave;
return c1.no - c2.no;
}

});

for (int time=startTime; time《=endTime; time++){
System.out.println("TIME:" + time);
for (int k=0;k《cars.length;k++){
Car car = cars;
//如果有车在没有进入停车场的时候就已经到了出库时间
if (car.leave == time && carStop.isFull() && !carStop.contains(car)){
for (int i=tunnel.size()-1;i》=0;i--){
Car c = tunnel.get(i);
if (c.equals(car)){
for (int j=i+1;j《tunnel.size();j++){
System.out.println(car + "为" + car + "让路，重新进入等待区");
}
tunnel.remove(car);
System.out.println(car + "没进入过停车场就离开了");
}else{
System.out.println(car + "为" + car + "让路");
}
}
}else{
// 如果有车子现在到达
if (car.arrive == time){
// 停车场不满
if (!carStop.isFull()) {
// 进入停车场
carStop.push(car);
// 开始计费
car.chargeStart = time;
System.out.println(car + "进入停车场并且开始计费");
}else{
// 停车场满，等待
System.out.println(car + "到达，在等待区等待");
tunnel.push(car);
}
}
}
}
//deal with cars in stop
//the case cars leave at same time is not included
// 按照后进先出的顺序看有没有车要离开
for (int k=carStop.size() - 1; k》=0; k--){
Car car = carStop.elementAt(k);
//准备离开
if (car.leave == time){
Car otherCar;
// 所有在他后面进来的车准备让路
while ((otherCar = carStop.pop())!=car){
// 进入等待区的最前面
tunnel.unshift(otherCar);
System.out.println(otherCar + "准备为" + car + "让路");
}
for (int m=tunnel.size()-1;m》=0;m--){
System.out.println(tunnel.elementAt(m) + "为" + car + "让路");
}
System.out.println(otherCar + "离开，停车时间:" + (otherCar.leave - otherCar.chargeStart));
for (int m=0; m《tunnel.size(); m++){
System.out.println(tunnel.elementAt(m) + "让路完毕，重新进入等待区");
}
Car waitingCar;
//停车场有空位，等待序列最前面的车入库
while ( !carStop.isFull() && (waitingCar = tunnel.shift())!=null ){
carStop.push(waitingCar);
// 停车计时开始
if (waitingCar.chargeStart == -1) {
System.out.println(waitingCar + "停车计时时间改为:" + time);
waitingCar.chargeStart = time;
}
System.out.println(waitingCar + "进入停车场");
}
}
}
}
}
public static void main(String args){
new Test().test();
}
}
@SuppressWarnings("serial")
class CarTunnel extends Vector《Car》{
public CarTunnel(){
super();
}
public Car shift(){
if (size() == 0) return null;
return remove(0);
}
public void unshift(Car car){
super.add(0, car);
}
public void push(Car car){
super.add(car);
}
public Car pop(){
if (size() == 0) return null;
return remove(size()-1);
}
}
@SuppressWarnings("serial")
class CarStop extends Stack《Car》{
private int size;
public CarStop(int size){
this.size = size;
}
public boolean isFull(){
return size() == size;
}
public Car pop(){
return super.pop();
}
public Car push(Car car){
if (size() 《= size){
return super.push(car);
}else{
return null;
}
}
}
class Car{
public int no;
public int arrive;
public int leave;
public int chargeStart = -1;
public Car(int no, int timeIn, int timeOut){
this.no = no;
this.arrive = timeIn;
this.leave = timeOut;
}

public Car(int no, int timeIn){
this(no, timeIn, -1);
}
public String toString(){
return String.format("Car(%d)", no);
}
}
结果：
(A,6,31)
(A,5,30)
(A,4,20)
(A,3,16)
(A,2,15)
(A,1,10)
(D,1,50)
(D,2,30)
(D,3,31)
(D,4,25)
(D,5,32)
(D,6,40)
(E,0,0)
TIME:10
Car(1)进入停车场并且开始计费
TIME:11
TIME:12
TIME:13
TIME:14
TIME:15
Car(2)进入停车场并且开始计费
TIME:16
Car(3)进入停车场并且开始计费
TIME:17
TIME:18
TIME:19
TIME:20
Car(4)到达，在等待区等待
TIME:21
TIME:22
TIME:23
TIME:24
TIME:25
Car(4)没进入过停车场就离开了
TIME:26
TIME:27
TIME:28
TIME:29
TIME:30
Car(5)到达，在等待区等待
Car(3)准备为Car(2)让路
Car(5)为Car(2)让路
Car(3)为Car(2)让路
Car(2)离开，停车时间:15
Car(3)让路完毕，重新进入等待区
Car(5)让路完毕，重新进入等待区
Car(3)进入停车场
Car(5)停车计时时间改为:30
Car(5)进入停车场
TIME:31
Car(6)到达，在等待区等待
Car(5)准备为Car(3)让路
Car(6)为Car(3)让路
Car(5)为Car(3)让路
Car(3)离开，停车时间:15
Car(5)让路完毕，重新进入等待区
Car(6)让路完毕，重新进入等待区
Car(5)进入停车场
Car(6)停车计时时间改为:31
Car(6)进入停车场
TIME:32
Car(6)准备为Car(5)让路
Car(6)为Car(5)让路
Car(5)离开，停车时间:2
Car(6)让路完毕，重新进入等待区
Car(6)进入停车场
TIME:33
TIME:34
TIME:35
TIME:36
TIME:37
TIME:38
TIME:39
TIME:40
Car(6)离开，停车时间:9
TIME:41
TIME:42
TIME:43
TIME:44
TIME:45
TIME:46
TIME:47
TIME:48
TIME:49
TIME:50
Car(1)离开，停车时间:40

急..用JAVA语言实现数据结构实验！

发了我大半天时间专门帮你写的，注释没写仔细，有什么不明白的或者有什么小bebug就给我留言。
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
public class Test {
//I/O读取文件
public String getFile(String path) {
StringBuffer context = new StringBuffer();
try {
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(path)));
String temp = br.readLine();
while (temp!=null) {
context.append(temp+"\n");
temp = br.readLine();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return context.toString().toLowerCase();
}
//分割内容方法
public List mySplit(String context) {
String words = {};
List all = new ArrayList();
//按标点符号，分割内容的正则表达式
String regex = "\\W";//
words = context.split(regex);
for(int i=0; i《words.length; i++) {
if(!words.equals(""))//把空格去掉
all.add(words);
}
return all;
}
//统计全部单词及其个数
public Hashtable contWords(List all) {
//用于保存全部的单词及其个数
Hashtable allTable = new Hashtable();
for(int i=0; i《all.size(); i++) {
//两个临时的变量，一个键一个值
String temp = all.get(i).toString();
int count = 0;
for(int j=0; j《all.size(); j++) {
if(temp.equalsIgnoreCase(all.get(j).toString())) {
count++;
}
}
allTable.put(temp, count);
}
return allTable;
}
//找出个数最多的那五个单词
public Hashtable findMax5(Hashtable allTable) {
//用于保存结果的Hashtable
Hashtable result = new Hashtable();
Object keyToValue = allTable.entrySet().toArray();
Object values = allTable.values().toArray();
int;
for(int i=0; i《values.length; i++) {
int value = Integer.parseInt(values.toString());
int min = findMin(v);
if(value》min) {
for(int j=0; j《v.length; j++) {
if(v==min) {
v = value;
break;
}
}
}
}
//把v里面的无素从大到小排序一下
for(int i=0; i《v.length; i++) {
for(int j=i+1; j《v.length; j++) {
if(v) {
int temp = v;
v;
v = temp;
}
}
}
for(int i=0; i《v.length; i++) {
// System.out.println(v);
for(int j=0; j《keyToValue.length; j++) {
String ktv = keyToValue.toString();
int tv = Integer.parseInt(ktv.substring(ktv.indexOf("=")+1));
if(v==tv) {
//保证只取五个频率最高的单词
if(result.size()》=5) break;
String key = ktv.substring(0, ktv.indexOf("="));
result.put(key, v);
}
}
}
return result;
}
//简单的查找数组中最小的那个数
public int findMin(int v) {
for(int i=0; i《v.length-1; i++) {
if(v) {
int temp = v;
v;
v = temp;
}
}
return v;
}
//打印出结果
public static void printResult(Hashtable result) {
System.out.println("排前五的单词情况如下：");
Enumeration e = result.keys();
Iterator it = result.values().iterator();
while (e.hasMoreElements()) {
System.out.println(e.nextElement() + " 的个数为： " + it.next());
}
}
//main方法
public static void main(String args) {
Test test = new Test();
String context = test.getFile("c:/test3.txt");
List all = test.mySplit(context);
Hashtable allTable = test.contWords(all);
Hashtable result = test.findMax5(allTable);
// System.out.println(result);
Test.printResult(result);
}
}

高手请帮忙用java版的数据结构，设置3个队列，实现入队出队

import java.util.ArrayList;
/**
*
* @author 狱韬
*/
public class SnakeBody {
private int size=0; //队列的长度
private int cursor=-1; //指针
private ArrayList《int》 list=null; //存储器
public SnakeBody() {
list=new ArrayList《int》(); //存储器
}
//返回底部的数据
public int getLast(){
return list.get(list.size()-1);
}
//返回顶部的数据
public int getFirst(){
return list.get(0);
}
//压入数据
public void put(int arry){
list.add(arry);
}
//删除底部数据
public void removeLast(){
list.remove(list.size()-1);
}
//重置
public void reSet(){
list=new ArrayList《int》(); //存储器
}
//删除顶部数据
public void removeFirst(){
list.remove(0);
}
//返回数据长度
public int size(){
return list.size();
}
public static void main(String args) {
SnakeBody data = new SnakeBody();
for(int i=0;i《10;i++){
data.put(new int{0,i});
}
System.out.println(data.getFirst());
System.out.println(data.getLast());
data.removeLast();
System.out.println(data.getFirst());
System.out.println(data.getLast());
}
}