java数据结构典型题
一、顺序表
interface IList{
public void clear();
public boolean isEmpty();
public Object get(int i) throws Exception;
public void insert(int i,Object x) throws Exception;
public void remove(int i) throws Exception;
public int indexOf(Object x);
public void display();
}
< SqList.java>
public class SqList implements IList{ private Object[] listElem;
private int curLen;
public SqList(int maxSize){
curLen=0;
listElem=new Object[maxSize];
}
public void clear(){
curLen=0;
}
public boolean isEmpty(){
return curLen==0;
}
public int lenght(){
return curLen;
}
public Object get(int i) throws Exception{ if(i<0||i>curLen-1)
throw new Exception("第"+i+"个元素不存在");
return listElem[i];
}
public void insert(int i,Object x) throws Exception{
if(curLen==listElem.length)
throw new Exception("顺序表已满");
if(i<0||i>curLen)
throw new Exception("插入位置不合法");
for(int j=curLen;j>i;j--)
listElem[j]=listElem[j-1];
listElem[i]=x;
curLen++;
}
public void remove(int i) throws Exception{
if(i<0||i>curLen-1)
throw new Exception("删除位置不合法");
for(int j=i;j listElem[j]=listElem[j+1]; curLen--; } public int indexOf(Object x) { int j=0; while(j if(j return j; else return-1; } public void display(){ for(int j=0;j System.out.print(listElem[j]+""); System.out.println(); } public static void main(String[] args) throws Exception{ SqList L=new SqList(50); L.insert(0,'a'); L.insert(1,'b'); L.insert(2,'c'); L.insert(3,'d'); L.insert(4,'e'); int order=L.indexOf('c'); if(order!=-1) System.out.println("顺序表中第一次出现的值为‘c’的数据元素的位置为:"+order); else System.out.println("此顺序表中不包含值为‘c’的数据元素!"); L.remove(2); System.out.println("删除后的顺序表为:"); L.display(); }} 顺序表中第一次出现的值为‘c’的数据元素的位置为:2 删除后的顺序表为: abde 二、链表 interface IList{ public void clear(); public boolean isEmpty(); public Object get(int i) throws Exception; public void insert(int i,Object x) throws Exception; public void remove(int i) throws Exception; public int indexOf(Object x); public void display(); public void nizhi(); } < Node.java > public class Node { private Object data; private Node next; public Node() { this(null,null); } public Node(Object data) { this(data,null); } public Node(Object data,Node next) { this.data=data; this.next=next; } public Object getData(){ return data; } public Node getNext() { return next; } public void setData(Object data) { this.data=data; } public void setNext(Node next) { this.next=next; } } < LinkList.java> import java.util.*; public class LinkList implements IList { private Node head; public LinkList(){ head=new Node(); } public LinkList(int n,boolean Order)throws Exception{ this(); if(Order) create1(n); else create2(n); } public void create1(int n)throws Exception { Scanner sc=new Scanner(System.in); for(int j=0;j insert(length(),sc.next()); } public void create2(int n)throws Exception { Scanner sc=new Scanner(System.in); for(int j=0;j insert(0,sc.next()); } public void clear(){ head.setData(null); head.setNext(null); } public boolean isEmpty(){ return head.getNext()==null; } public int length(){ Node p=head.getNext(); int length = 0; while(p!=null) { p=p.getNext(); ++length; } return length; } public Object get(int i) throws Exception { Node p=head.getNext(); int j=0; while(p!=null&&j p=p.getNext(); ++j; } if(j>i||p==null) { throw new Exception("第"+i+"个元素不存在"); } return p.getData(); } public void insert(int i,Object x)throws Exception { Node p=head; int j=-1; while(p!=null&&j { p=p.getNext(); ++j; } if(j>i-1||p==null) throw new Exception("插入位置不合法"); Node s=new Node(x); s.setNext(p.getNext()); p.setNext(s); } public void remove (int i)throws Exception { Node p=head; int j=-1; while(p.getNext()!=null&&j { p=p.getNext(); ++j; } if(j>i-1||p.getNext()==null) throw new Exception("删除位置不合法"); p.setNext(p.getNext().getNext()); } public int indexOf(Object x) { Node p=head.getNext(); int j=0; while(p!=null&&!p.getData().equals(x)) { p=p.getNext(); ++j; } if(p!=null) return j; else return -1; } public void display(){ Node node=head.getNext(); while(node!=null) { System.out.print(node.getData()+" "); node=node.getNext(); } System.out.println();} public void nizhi() { Node p=head.getNext(); Node q; head.setNext(null); while(p!=null) { q=p.getNext(); p.setNext(head.getNext()); head.setNext(p); p=q; }} public static void main(String[] args) throws Exception{ int n=10; LinkList L=new LinkList(); for(int i=0;i L.insert(i, i); L.insert(11, 22); L.remove(2); System.out.println("删除后的单链表表为:"); L.display(); }} import java.util.*; public class test { public static void main(String[] args) throws Exception{ int a; System.out.println("请输入5个结点值:"); LinkList L=new LinkList(5,true); System.out.println("插入的字符为:"); int x=new Scanner(System.in).nextInt(); System.out.println("插入的位置为:"); int y=new Scanner(System.in).nextInt(); L.insert(y,x); L.display(); System.out.println("单链表的长度为:"); a=L.length(); System.out.println(a); System.out.println("所删除字符的结点值为:"); Int n=new Scanner(System.in).nextInt(); L.remove(n); L.display(); System.out.println("请输入要查询的结点值:"); Int i=new Scanner(System.in).nextInt(); if(0 System.out.println("位置"+i+"的元素的 值是:"+L.get(i)); } else System.out.println("位置"+i+"的元素不 存在"); System.out.println("实现单链表逆置"); L.nizhi(); L.display(); }} 请输入5个结点值: a b c d e 插入的字符为: 1 插入的位置为: 2 a b 1 c d e 单链表的长度为: 6 所删除字符的结点值为: 2 a b c d e 请输入要查询的结点值: 3 位置3的元素的值是:d 实现单链表逆置 e d c b a 三、栈 public interface IStack { public void clear(); public boolean isEmpty(); public int length(); public Object peek(); public void push(Object x) throws Exception; public Object pop(); } public class SqStack implements IStack{ private Object[] stackElem; private int top; public SqStack(int maxSize) { top=0; stackElem=new Object[maxSize]; } public void clear(){ top=0; } public boolean isEmpty(){ return top==0; } public int length(){ return top; } public Object peek(){ if(!isEmpty()) return stackElem[top-1]; else return null; } public void push(Object x) throws Exception { if(top==stackElem.length) throw new Exception("栈已满"); else stackElem[top++]=x; } public Object pop() { if(isEmpty()) return null; else return stackElem[--top]; } public void display() { for(int i=top-1;i>=0;i--) System.out.print(stackElem[i].toString( )+""); }} import java.util.*; public class teststack { public static void main(String[] args) throws Exception { SqStack S = new SqStack(100); // 初始化一个新的容量为100的顺序栈 Scanner sc=new Scanner(System.in); System.out.print("请输入顺序栈的长度:"); int n=sc.nextInt(); System.out.println("请输入顺序栈中的各个数据元素值(数字):"); for(int i=0;i S.push(sc.nextInt()); System.out.println("建立的顺序栈中各元素为(从栈顶到栈底): "); S.display(); System.out.println(); System.out.println("请输入待入栈的数据值e(数字):"); int e=sc.nextInt(); S.push(e); System.out.println("入栈后的顺序栈中各元素为(从栈顶到栈底):"); S.display(); System.out.println(); System.out.println(" 取栈顶元素 值为: "); System.out.println(S.peek()); System.out.println("去除栈顶元素后,顺序栈中各元素为(从栈顶到栈底): "); S.pop(); S.display(); } } 请输入顺序栈的长度:5 请输入顺序栈中的各个数据元素值(数字): 1 2 3 4 5 建立的顺序栈中各元素为(从栈顶到栈底): 54321 请输入待入栈的数据值e(数字): 9 入栈后的顺序栈中各元素为(从栈顶到栈底): 954321 取栈顶元素值为: 9 去除栈顶元素后,顺序栈中各元素为(从栈顶到栈底):54321 四、(1) 队列(循环) public interface IQueue { public void clear(); public boolean isEmpty(); public int length(); public Object peek(); public void offer(Object x) throws Exception; public Object poll(); } public class CircleSqQueue { private Object[] queueElem; private int front; private int rear; public CircleSqQueue(int maxSize){ front=rear=0; queueElem=new Object[maxSize]; } public void clear(){ front=rear=0; } public boolean isEmpty(){ return front==rear; } public int length(){ return(rear-front+queueElem.length)%que ueElem.length; } public Object peek(){ if(front==rear) return null; else return queueElem[front]; } public void offer(Object x) throws Exception{ if((rear+1)%queueElem.length==front) throw new Exception("队列已满"); else { queueElem[rear]=x; rear=(rear+1)%queueElem.length; } } public Object poll(){ if(front==rear) return null; else{ Object t=queueElem[front]; front=(front+1)%queueElem.length; return t; }} public void display(){ if(!isEmpty()){ for(int i=front;i!=rear;i=(i+1)% queueElem.length) System.out.print(queueElem[i].toString( )+""); } else System.out.println("此队列为空"); }} import java.util.*; public class test { public static void main(String[] args) throws Exception { CircleSqQueue S = new CircleSqQueue(100); // 初始化一个新的容量为100的顺序栈 Scanner sc=new Scanner(System.in); System.out.print("请输入循环队列的长度:"); int n=sc.nextInt(); System.out.println("请输入循环队列中的各个数据元素值(数字):"); for(int i=0;i S.offer(sc.nextInt()); System.out.println("建立的循环队列中各元素为: "); S.display(); System.out.println(); System.out.println(" 取队首元素 值为: "); System.out.println(S.peek()); System.out.println("去除队首元素后,循环队列中各元素为: "); S.poll(); S.display(); }} 请输入循环队列的长度:5 请输入循环队列中的各个数据元素值(数字): 1 2 3 4 5 建立的循环队列中各元素为: 12345 取队首元素值为: 1 去除队首元素后,循环队列中各元素为: 2345 (2)队列(链式) public class Node { private Object data; private Node next; public Node() { this(null,null); } public Node(Object data) { this(data,null); } public Node(Object data,Node next) { this.data=data; this.next=next; } public Object getData(){ return data; } public Node getNext() { return next; } public void setData(Object data) { this.data=data; } public void setNext(Node next) { this.next=next; } } public interface IQueue { public void clear(); public boolean isEmpty(); public int length(); public Object peek(); public void offer(Object x) throws Exception; public Object poll(); } < LinkQueue.java > import java.util.Scanner; public class LinkQueue implements IQueue{ private Node front; private Node rear; public LinkQueue(){ front=rear=null; } public void clear(){ front=rear=null; } public boolean isEmpty() { return front==null; } public int length() { if(!isEmpty()) { Node p=front; int length = 0; while(p!=null) { p=p.getNext(); ++length; } } return length(); } public Object peek(){ if(front!=null) return front.getData(); else return null; } public void offer(Object x) { Node p=new Node(x); if(front!=null){ rear.setNext(p); rear=p; } else front=rear=p; } public Object poll(){ if(front!=null){ Node p=front; front=front.getNext(); if(p==rear) rear=null; return p.getData(); } else return null; } public void display(){ Node p=front; while(p!=null){ System.out.print(p.getData().toString() +" "); p=p.getNext(); } System.out.println(); } public static void main(String[] args) throws Exception{ Scanner sc=new Scanner(System.in); LinkQueue L=new LinkQueue(); System.out.print("请输入链队列的长度:"); int n=sc.nextInt(); System.out.println("请输入链队列中的各个数据元素值:"); for(int i=0;i L.offer(sc.nextInt()); System.out.println("建立的链队列中各元素为: "); L.display(); System.out.println(); System.out. println(" 取队首元素值为: "); System.out.println(L.peek()); System.out.println("去除队首元素后,链队列中各元素为: "); L.poll(); L.display(); }} 答案与循环队列相同 五、二叉树 class BiTreeNode { private Object data; private BiTreeNode lchild, rchild; public BiTreeNode() { this(null); } public BiTreeNode(Object data) { this(data,null,null); } public BiTreeNode(Object data, BiTreeNode lchild, BiTreeNode rchild) {// 构造一棵数据元素和左右孩子都不为空的结点 this.data = data; this.lchild = lchild; this.rchild = rchild; } public Object getData() { return data; } public void setData(Object data) { this.data = data; } public BiTreeNode getLchild() { return lchild; } public void setLchild(BiTreeNode lchild) { this.lchild = lchild; } public BiTreeNode getRchild() { return rchild; } public void setRchild(BiTreeNode rchild) { this.rchild = rchild; }} public class BiTree { protected BiTreeNode root; public BiTree() { root = null; } public BiTree(BiTreeNode root) { this.root = root; } public BiTree (String preOrder,String inOrder,int preIndex,int inIndex,int count){ if(count>0){ char r=preOrder.charAt(preIndex); int i=0; for(;i if(r==preOrder.charAt(i+inIndex)) break; root=new BiTreeNode(r); root.setLchild(new BiTree(preOrder, inOrder,preIndex+1,inIndex,i).root); root.setRchild(new BiTree(preOrder, inOrder,preIndex+i+1,inIndex+i+1,count-i-1) .root); } } } private static int index = 0; public BiTree(String preStr) { char c = preStr.charAt(index++); if (c != '#') { root = new BiTreeNode(c); root.setLchild(new BiTree(preStr).root); root.setRchild(new BiTree(preStr).root); } else root = null; } public void preRootTraverse(BiTreeNode T){ if(T!=null){ System.out.print(T.getData()); preRootTraverse(T.getLchild()); preRootTraverse(T.getRchild()); }} public void inRootTraverse(BiTreeNode T){ if(T!=null){ inRootTraverse(T.getLchild()); System.out.print(T.getData()); inRootTraverse(T.getRchild()); }} public void postRootTraverse(BiTreeNode T){ if(T!=null){ postRootTraverse(T.getLchild()); postRootTraverse(T.getRchild()); System.out.print(T.getData()); }} public int countNode(BiTreeNode T){ int count=0; if(T!=null){ ++count; count+=countNode(T.getLchild()); count+=countNode(T.getRchild()); } return count; } public int getDepth(BiTreeNode T){ if(T!=null) { int lDepth=getDepth(T.getLchild()); int rDepth=getDepth(T.getRchild()); return 1+(lDepth>rDepth?lDepth:rDepth); } return 0; } public BiTreeNode getRoot() { return root; } public void setRoot(BiTreeNode root) { this.root = root; } public int leaf(BiTreeNode T) { if (T == null) return 0; else { int left = leaf(T.getLchild()); int right = leaf(T.getRchild()); if (T.getLchild() == null && T.getRchild() == null) return left + right + 1; else return left + right; } }} public class TestTree { public static void main(String[] arg){ String preStr="AB##CD###"; BiTree T= new BiTree(preStr); BiTreeNode root=T.getRoot(); System.out.println("先根遍历:"); T.preRootTraverse(root); System.out.println(); System.out.println("中根遍历:"); T.inRootTraverse(root); System.out.println(); System.out.println("后根遍历:"); T.postRootTraverse(root); System.out.println(); System.out.println("结点个数为: "+T.countNode(root)); System.out.println("叶子节点总数为:"+T.leaf(root)); System.out.println("深度为: "+T.getDepth(root)); }} 先根遍历: ABCD 中根遍历: BADC 后根遍历: BDCA 结点个数为:4 叶子节点总数为:2 深度为:3 六、图的遍历(邻接矩阵) 调用队列输出矩阵: public class Node { private Object data; private Node next; public Node() { this(null,null); } public Node(Object data) { this(data,null); } public Node(Object data,Node next) { this.data=data; this.next=next; } public Object getData(){ return data; } public Node getNext() { return next; } public void setData(Object data) { this.data=data; } public void setNext(Node next) { this.next=next; }} public interface IQueue { public void clear(); public boolean isEmpty(); public int length(); public Object peek(); public void offer(Object x) throws Exception; public Object poll(); } < LinkQueue.java > import java.util.Scanner; public class LinkQueue implements IQueue{ private Node front; private Node rear; public LinkQueue(){ front=rear=null; } public void clear(){ front=rear=null; } public boolean isEmpty() { return front==null; } public int length() { if(!isEmpty()) { Node p=front; int length = 0; while(p!=null) { p=p.getNext(); ++length; } } return length(); } public Object peek(){ if(front!=null) return front.getData(); else return null; } public void offer(Object x) { Node p=new Node(x); if(front!=null){ rear.setNext(p); rear=p; } else front=rear=p; } public Object poll(){ if(front!=null){ Node p=front; front=front.getNext(); if(p==rear) rear=null; return p.getData(); } else return null; } public void display(){ Node p=front; while(p!=null){ System.out.print(p.getData().toString() +" "); p=p.getNext(); } System.out.println(); } } public interface IGraph { int getVexNum(); int getArcNum(); Object getVex(int v) throws Exception; int locateVex(Object vex); int firstAdjVex(int v)throws Exception; int nextAdjVex(int v,int w)throws Exception; } import java.util.Scanner; public class MGraph implements IGraph{ public final static int INFINITY=Integer.MAX_VALUE; private int vexNum,arcNum; private Object[] vexs; private int[][] arcs; public MGraph(){ this(0,0,null,null); } public MGraph(int vexNum,int arcNum,Object[] vexs,int[][] arcs){ this.vexNum=vexNum; this.arcNum=arcNum; this.vexs=vexs; this.arcs=arcs; } public void createUDG(){ Scanner sc=new Scanner(System.in); System.out.println("请分别输入图的顶点数和图的边数:"); vexNum=sc.nextInt(); arcNum=sc.nextInt(); vexs=new Object[vexNum]; System.out.println("请分别输入图的各个顶点:"); for(int v=0;v vexs[v]=sc.next(); arcs=new int[vexNum][vexNum]; for(int v=0;v for(int u=0;u arcs[v][u]=0; System.out.println("请输入各个边的两个顶点及其权值:"); for(int k=0;k int v=locateVex(sc.next()); int u=locateVex(sc.next()); arcs[v][u]=arcs[u][v]=1; }} public int getVexNum(){ return vexNum; } public int getArcNum(){ return arcNum; } public int locateVex(Object vex){ for(int v=0;v if(vexs[v].equals(vex)) return v; return -1; } public Object getVex(int v) throws Exception{ if(v<0&&v>=vexNum) throw new Exception("第"+v+"个顶点不存在!"); return vexs[v]; } public int firstAdjVex(int v) throws Exception{ if(v<0&&v>=vexNum) throw new Exception("第"+v+"个顶点不存在!"); for(int j=0;j if(arcs[v][j]!=0&&arcs[v][j] return j; return -1; } public int nextAdjVex(int v,int w)throws Exception{ if(v<0&&v>=vexNum) throw new Exception("第"+v+"个顶点不存在!"); for(int j=w+1;j if(arcs[v][j]!=0&&arcs[v][j] return j; return -1; } public O bject[] getVexs(){ return vexs; } public int[][] getArcs(){ return arcs; }} public class DTraverser { private static boolean[] visited;// 访问标志数组 // 对图G做深度优先遍历 public static void DFSTraverse(IGraph G) throws Exception { visited= new boolean[G.getVexNum()]; for(int v = 0; v < G.getVexNum(); v++) // 访问标志数组初始化 visited[v] = false; for(int v = 0; v < G.getVexNum(); v++) if (!visited[v])// 对尚未访问的顶点调用DFS DFS(G, v); } // 从第v个顶点出发递归地深度优先遍历图G public static void DFS(IGraph G, int v) throws Exception { visited[v] = true; System.out.print(G.getVex(v).toString() + " ");// 访问第v个顶点 for(int w = G.firstAdjVex(v); w >= 0; w = G.nextAdjVex(v, w)) if(!visited[w])// 对v的尚未访问的邻接顶点w递归调用DFS DFS(G, w); } // 对图G做广度优先遍历 public static void BFSTraverse(IGraph G) throws Exception { visited = new boolean[G.getVexNum()];// 访问标志数组 for(int v = 0; v < G.getVexNum(); v++) // 访问标志数组初始化 visited[v] = false; for(int v = 0; v < G.getVexNum(); v++) if (!visited[v]) // v尚未访问 BFS(G, v); } private static void BFS(IGraph G, int v) throws Exception { visited[v] = true; System.out.print(G.getVex(v).toString() + " "); LinkQueue Q = new LinkQueue();// 辅助队列Q Q.offer(v);// v入队列 while (!Q.isEmpty()) { int u = (Integer) Q.poll();// 队头元素出队列并赋值给u for(int w = G.firstAdjVex(u); w >= 0; w = G.nextAdjVex(u, w)) if (!visited[w]) {// w为u的尚未访问的邻接顶点 visited[w] = true; System.out.print(G.getVex(w).toString() + " "); Q.offer(w); }} }} public class TestJZ { public static void main(String[] args) throws Exception { MGraph G =new MGraph(); G.createUDG(); for(int i=0;i System.out.println(); for(int i=0;i System.out.print(G.getVex(i)+"\t"); for(int j=0;j System.out.println(); } System.out.print("无向图的广度优先遍历 序列为:"); DTraverser.BFSTraverse(G); System.out.println(); System.out.print("无向图的深度优先遍历序列为:"); DTraverser.DFSTraverse(G); System.out.println(); }} 请分别输入图的顶点数和图的边数: 4 5 请分别输入图的各个顶点: v0 v1 v2 v3 请输入各个边的两个顶点及其权值: v0 v1 v0 v2 v2 v3 v3 v1 v3 v0 v0 v1 v2 v3 v0 0 1 1 1 v1 1 0 0 1 v2 1 0 0 1 v3 1 1 1 0 无向图的广度优先遍历序列为:v0 v1 v2 v3 无向图的深度优先遍历序列为:v0 v1 v3 v2 七、图的应用(邻接表) 调用队列输出矩阵: public class Node { private Object data; private Node next; public Node() { this(null,null); } public Node(Object data) { this(data,null); } public Node(Object data,Node next) { this.data=data; this.next=next; } public Object getData(){ return data; } public Node getNext() { return next; } public void setData(Object data) { this.data=data; } public void setNext(Node next) { this.next=next; }} public interface IQueue { public void clear(); public boolean isEmpty(); public int length(); public Object peek(); public void offer(Object x) throws Exception; public Object poll(); } < LinkQueue.java > import java.util.Scanner; public class LinkQueue implements IQueue{ private Node front; private Node rear; public LinkQueue(){ front=rear=null; } public void clear(){ front=rear=null; } public boolean isEmpty() { return front==null; } public int length() { if(!isEmpty()) { Node p=front; int length = 0; while(p!=null) { p=p.getNext(); ++length; } } return length(); } public Object peek(){ if(front!=null) return front.getData(); else return null; } public void offer(Object x) { Node p=new Node(x); if(front!=null){ rear.setNext(p); rear=p; } else front=rear=p; } public Object poll(){ if(front!=null){ Node p=front; front=front.getNext(); if(p==rear) rear=null; return p.getData(); } else return null; } public void display(){ Node p=front; while(p!=null){ System.out.print(p.getData().toString() +" "); p=p.getNext(); } System.out.println(); } } public class VNode { private Object data; private ArcNode firstArc; public VNode(){ this(null,null); } public VNode(Object data){ this(data,null); } public VNode(Object data,ArcNode firstArc){ this.data=data; this.firstArc=firstArc; } public Object getData(){ return data; } public ArcNode getFirstArc(){ return firstArc; } public void setData(Object data){ this.data=data; } public void setFirstArc(ArcNode firstArc){ this.firstArc=firstArc; }} public class ArcNode { private int adjVex; private int value; private ArcNode nextArc; public ArcNode(){ this(-1,0,null); } public ArcNode(int adjVex){ this(adjVex,0,null); } public ArcNode(int adjVex,int value){ this(adjVex,value,null); } public ArcNode(int adjVex,int value,ArcNode nextArc){ this.value=value; this.adjVex=adjVex; this.nextArc=nextArc; } public int getValue(){ return value; } public ArcNode getNextArc(){ return nextArc; } public int getAdjVex(){ return adjVex; } public void setAdjVex(int adjVex){ this.adjVex=adjVex; } public void setValue(int value){ this.value=value; } public void setNextArc(ArcNode nextArc){ this.nextArc=nextArc; } } import java.util.*; public class ALGraph implements IGaph{ private int vexNum,arcNum; private VNode[] vexs; private int[][] arcs; public ALGraph(){ this(0,0,null); } public ALGraph(int vexNum,int arcNum,VNode[] vexs){ this.vexNum=vexNum; this.arcNum=arcNum; this.vexs=vexs; } public void createDN(){ Scanner sc=new Scanner(System.in); System.out.print("请分别输入图的顶点数,图的边数:"); vexNum=sc.nextInt(); arcNum=sc.nextInt(); vexs=new VNode[vexNum]; System.out.print("请分别输入图的个顶点:"); for(int v=0;v vexs[v]=new VNode(sc.next()); System.out.println("请输入个边的顶点及 其权值:"); for(int k=0;k int v=locateVex(sc.next()); int u=locateVex(sc.next()); int value=sc.nextInt(); addArc(v,u,value); }} public void addArc(int v,int u,int value){ ArcNode arc=new ArcNode(u,value); arc.setNextArc(vexs[v].getFirstArc()); vexs[v].setFirstArc(arc); } public int getVexNum(){ return vexNum; } public int getArcNum(){ return arcNum; } public int locateVex(Object vex){ for(int v=0;v if(vexs[v].getData().equals(vex)) return v; return -1; } public VNode[] getVexs() { return vexs; } public Object getVex(int v)throws Exception{ if(v<0&&v>=vexNum) throw new Exception("第"+v+"个顶点不存在"); return vexs[v].getData(); } public int firstAdjVex(int v)throws Exception{ if(v<0&&v>=vexNum) throw new Exception("第"+v+"个顶点不存在"); VNode vex=vexs[v]; if(vex.getFirstArc()!=null) return vex.getFirstArc().getAdjVex(); else return -1; } public int nextAdjVex(int v,int w)throws Exception{ if(v<0&&v>=vexNum) throw new Exception("第"+v+"个顶点不存在"); VNode vex=vexs[v]; ArcNode arcvw=null; for(ArcNode arc=vex.getFirstArc();arc!=null;arc=arc.get NextArc()) if(arc.getAdjVex()==w){ arcvw=arc; break; } if(arcvw!=null&&arcvw.getNextArc()!=null) return arcvw.getNextArc().getAdjVex(); else return -1; } public void display(ALGraph G)throws Exception{ for(int i=0;i for(int w=G.firstAdjVex(i);w!=-1; w=G.nextAdjVex(i, w)){ System.out.print(G.getVex(w)+"\t"); } System.out.println(); }} } public interface IGaph { int getVexNum(); int getArcNum(); Object getVex(int v)throws Exception; int locateVex(Object vex); int firstAdjVex(int v)throws Exception; int nextAdjVex(int v,int w)throws Exception; } public class Path { private boolean[] visited; private int i=0; private boolean find =false; public void findPath(IGaph G,int u,int v,int k) throws Exception{ visited=new boolean[G.getVexNum()]; for(int w=0;w visited[w]=false; find_DFS(G,u,v,k); if(find) System.out.println(G.getVex(u)+"和"+G.getVex(v)+"之间存在一条长度为"+k+"的简单 路径"); else System.out.println(G.getVex(u)+"和"+G.getVex(v)+"之间不存在一条长度为"+k+"的简 单路径"); } public void find_DFS(IGaph G,int u,int v,int k)throws Exception{ if(i==k&&u==v) find=true; else if(!find){ visited[u]=true; for(int w=G.firstAdjVex(u);w>=0;w=G.next AdjVex(u, w)) if(!visited[w]){ if(i ++i; find_DFS(G,w,v,k); } else break; } --i; }} } public class DTraverser { private static boolean[] visited;// 访问标志数组 // 对图G做深度优先遍历 public static void DFSTraverse(IGraph G) throws Exception { visited= new boolean[G.getVexNum()]; for(int v = 0; v < G.getVexNum(); v++) // 访问标志数组初始化 visited[v] = false; for(int v = 0; v < G.getVexNum(); v++) if (!visited[v])// 对尚未访问的顶点调用DFS DFS(G, v); } // 从第v个顶点出发递归地深度优先遍历图G public static void DFS(IGraph G, int v) throws Exception { visited[v] = true; System.out.print(G.getVex(v).toString() + " ");// 访问第v个顶点 for(int w = G.firstAdjVex(v); w >= 0; w = G.nextAdjVex(v, w)) if(!visited[w])// 对v的尚未访问的邻接顶点w递归调用DFS DFS(G, w); } // 对图G做广度优先遍历 public static void BFSTraverse(IGraph G) throws Exception { visited = new boolean[G.getVexNum()];// 访问标志数组 for(int v = 0; v < G.getVexNum(); v++) // 访问标志数组初始化 visited[v] = false; for(int v = 0; v < G.getVexNum(); v++) if (!visited[v]) // v尚未访问 BFS(G, v); } private static void BFS(IGraph G, int v) throws Exception { visited[v] = true; System.out.print(G.getVex(v).toString() + " "); LinkQueue Q = new LinkQueue();// 辅助队列Q Q.offer(v);// v入队列 while (!Q.isEmpty()) { int u = (Integer) Q.poll();// 队头元素出队列并赋值给u for(int w = G.firstAdjVex(u); w >= 0; w = G.nextAdjVex(u, w)) if (!visited[w]) {// w为u的尚未访问的邻接顶点 visited[w] = true; System.out.print(G.getVex(w).toString() + " "); Q.offer(w); }} }} public class TestB { public static void main(String[] args) throws Exception { ALGraph G =new ALGraph(); G.createDN(); G.display(G); System.out.print("有向图的广度优先遍历 序列为:"); DTraverser.BFSTraverse(G); System.out.println(); System.out.print("有向图的深度优先遍历序列为:"); DTraverser.DFSTraverse(G); System.out.println(); Path p=new Path(); p.findPath(G, 0, 3, 2); }} 请分别输入图的顶点数,图的边数:4 5 请分别输入图的个顶点:A B C D 请输入个边的顶点及其权值: A B 1 A C 4 C D 7 D C 4 A D 6 A:D C B B: C:D D:C 有向图的广度优先遍历序列为:A B C D 有向图的深度优先遍历序列为:A D C B A和D之间存在一条长度为1的简单路径 图 1. 填空题 ⑴ 设无向图G中顶点数为n,则图G至少有()条边,至多有()条边;若G为有向图,则至少有()条边,至多有()条边。 【解答】0,n(n-1)/2,0,n(n-1) 【分析】图的顶点集合是有穷非空的,而边集可以是空集;边数达到最多的图称为完全图,在完全图中,任意两个顶点之间都存在边。 ⑵ 任何连通图的连通分量只有一个,即是()。 【解答】其自身 ⑶ 图的存储结构主要有两种,分别是()和()。 【解答】邻接矩阵,邻接表 【分析】这是最常用的两种存储结构,此外,还有十字链表、邻接多重表、边集数组等。 ⑷ 已知无向图G的顶点数为n,边数为e,其邻接表表示的空间复杂度为()。 【解答】O(n+e) 【分析】在无向图的邻接表中,顶点表有n个结点,边表有2e个结点,共有n+2e个结点,其空间复杂度为O(n+2e)=O(n+e)。 ⑸ 已知一个有向图的邻接矩阵表示,计算第j个顶点的入度的方法是()。 【解答】求第j列的所有元素之和 ⑹ 有向图G用邻接矩阵A[n][n]存储,其第i行的所有元素之和等于顶点i的()。 【解答】出度 ⑺ 图的深度优先遍历类似于树的()遍历,它所用到的数据结构是();图的广度优先遍历类似于树的()遍历,它所用到的数据结构是()。 【解答】前序,栈,层序,队列 ⑻ 对于含有n个顶点e条边的连通图,利用Prim算法求最小生成树的时间复杂度为(),利用Kruskal 算法求最小生成树的时间复杂度为()。 【解答】O(n2),O(elog2e) 【分析】Prim算法采用邻接矩阵做存储结构,适合于求稠密图的最小生成树;Kruskal算法采用边集数组做存储结构,适合于求稀疏图的最小生成树。 ⑼ 如果一个有向图不存在(),则该图的全部顶点可以排列成一个拓扑序列。 【解答】回路 ⑽ 在一个有向图中,若存在弧、、,则在其拓扑序列中,顶点vi, vj, vk的相对次序为()。 【解答】vi, vj, vk 【分析】对由顶点vi, vj, vk组成的图进行拓扑排序。 2. 选择题 ⑴ 在一个无向图中,所有顶点的度数之和等于所有边数的()倍。 A 1/2 B 1 C 2 D 4 【解答】C 【分析】设无向图中含有n个顶点e条边,则。 精心整理面试时的Java数据结构与算法 查找和排序算法是算法的入门知识,其经典思想可以用于很多算法当中。因为其实现代码较短,应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗,只要熟悉了思想,灵活运用也不是难事。一般在面试中最常考的是 对5,3,8,6,4这个无序序列进行冒泡排序。首先从后向前冒泡,4和6比较,把4交换到前面,序列变成5,3,8,4,6。同理4和8交换,变成5,3,4,8,6,3和4无需交换。5和3交换,变成3,5,4,8,6,3.这样一次冒泡就完了,把最小的数3排到最前面了。对剩下的序列依次冒泡就会得到一个有序序列。冒泡排序的时间复杂度为O(n^2)。 实现代码: /** *@Description:冒泡排序算法实现*@author王旭 */ publicclassBubbleSort{ } } } } arr[i]=arr[j]; arr[j]=temp; } } 选择排序 选择排序的思想其实和冒泡排序有点类似,都是在一次排序后把最小的元素放到最前面。但是过程不同,冒泡排序是通过相邻的比较和交换。而选择排序是通过对整体的选择。举个栗子,对5,3,8,6,4这个无序序列进行简单选择排序,首先要选择5以外的最小数来和5交换,也就是选择3和5交换,一次排序后就变成了3,5,8,6,4.对剩下的序列一次进行选择和交换,最终就会得到一个有序序列。其实选择排序可 /** */ minIndex=i; for(intj=i+1;j//从i+1开始比较,因为minIndex默认为i了,i就没必要比了。 if(arr[j]arr[minIndex]){ minIndex=j; } 第二章算法分析 1.算法分析是计算机科学的基础 2.增长函数表示问题(n)大小与我们希望最优化的值之间的关系。该函数表示了该算法的时间复杂度或空间复杂度。增长函数表示与该问题大小相对应的时间或空间的使用 3.渐进复杂度:随着n的增加时增长函数的一般性质,这一特性基于该表达式的主项,即n 增加时表达式中增长最快的那一项。 4.渐进复杂度称为算法的阶次,算法的阶次是忽略该算法的增长函数中的常量和其他次要项,只保留主项而得出来的。算法的阶次为增长函数提供了一个上界。 5.渐进复杂度:增长函数的界限,由增长函数的主项确定的。渐进复杂度类似的函数,归为相同类型的函数。 6.只有可运行的语句才会增加时间复杂度。 7. O() 或者大O记法:与问题大小无关、执行时间恒定的增长函数称为具有O(1)的复杂度。 增长函数阶次 t(n)=17 O(1) t(n)=3log n O(log n) t(n)=20n-4 O(n) t(n)=12n log n + 100n O(n log n) t(n)=3n2+ 5n - 2 O(n2) t(n)=8n3+ 3n2O(n3) t(n)=2n+ 18n2+3n O(2n) 8.所有具有相同阶次的算法,从运行效率的角度来说都是等价的。 9.如果算法的运行效率低,从长远来说,使用更快的处理器也无济于事。 10.要分析循环运行,首先要确定该循环体的阶次n,然后用该循环要运行的次数乘以它。(n 表示的是问题的大小) 11.分析嵌套循环的复杂度时,必须将内层和外层循环都考虑进来。 12.方法调用的复杂度分析: 如:public void printsum(int count){ int sum = 0 ; for (int I = 1 ; I < count ; I++) sum += I ; System.out.println(sun); } printsum方法的复杂度为O(n),计算调用该方法的初始循环的时间复杂度,只需把printsum方法的复杂度乘以该循环运行的次数即可。所以调用上面实现的printsum方法的复 杂度为O(n2)。 13指数函数增长> 幂函数增长> 对数函数增长 单项选择 ( B ) 1. 通常所说的主机是指∶ A) CPU B) CPU和内存C) CPU、内存与外存D) CPU、内存与硬盘 ( C )2. 在计算机内部,一切信息的存取、处理和传送的形式是∶ A) ACSII码B) BCD码C)二进制D)十六进制 ( D )3. 软件与程序的区别是∶ A)程序价格便宜、软件价格昂贵; B)程序是用户自己编写的,而软件是由厂家提供的; C) 程序是用高级语言编写的,而软件是由机器语言编写的; D) 软件是程序以及开发、使用和维护所需要的所有文档的总称,而程序只是软件的一部分。 ( C )4. 所谓“裸机”是指∶ A) 单片机B)单板机C) 不装备任何软件的计算机D) 只装备操作系统的计算机 ( D )5. 应用软件是指∶ A)所有能够使用的软件B) 能被各应用单位共同使用的某种软件 C)所有微机上都应使用的基本软件D) 专门为某一应用目的而编制的软件 (A)6. C语言中的常量可分为整型常量、实型常量、字符型常量及(枚举)四种。 (A)符号常量(B)长整型常量(C)逻辑常量(D)二进制整数 ( C )7. 编译程序的功能是∶ A)发现源程序中的语法错误B)改正源程序中的语法错误 C)将源程序编译成目标程序D)将某一高级语言程序翻译成另一种高级语言程序 (A)8. 系统软件中最重要的是∶ A) 操作系统B) 语言处理系统C) 工具软件D) 数据库管理系统 ( C )9. 可移植性最好的计算机语言是∶ A) 机器语言B)汇编语言C) 高级语言D) 自然语言 ( B )10. 非线性结构是数据元素之间存在一种: A)一对多关系B)多对多关系C)多对一关系D)一对一关系 ( C )11. 数据结构中,与所使用的计算机无关的是数据的结构; A) 存储B) 物理C) 逻辑D) 物理和存储 ( C )12. 算法分析的目的是: A) 找出数据结构的合理性B) 研究算法中的输入和输出的关系 C) 分析算法的效率以求改进D) 分析算法的易懂性和文档性 (A)13. 算法分析的两个主要方面是: A) 空间复杂性和时间复杂性B) 正确性和简明性 C) 可读性和文档性D) 数据复杂性和程序复杂性 ( C )14. 计算机算法指的是: A) 计算方法B) 排序方法C) 解决问题的有限运算序列D) 调度方法 ( B )15. 计算机算法必须具备输入、输出和等5个特性。 A) 可行性、可移植性和可扩充性B) 可行性、确定性和有穷性 C) 确定性、有穷性和稳定性D) 易读性、稳定性和安全性 ( C )16.数据在计算机存储器内表示时,物理地址与逻辑地址相同并且是连续的,称之为: (A)存储结构(B)逻辑结构(C)顺序存储结构(D)链式存储结构 ( B )17.一个向量第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是 (A)110 (B)108 (C)100 (D)120 (A)18. 在n个结点的顺序表中,算法的时间复杂度是O(1)的操作是:(A)访问第i个结点(1≤i≤n)和求第i个结点的直接前驱(2≤i≤n) (B)在第i个结点后插入一个新结点(1≤i≤n) (C)删除第i个结点(1≤i≤n) (D)将n个结点从小到大排序 ( B )19. 向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变,平均要移动个元素 (A)8 (B)63.5 (C)63 (D)7 (A)20. 链接存储的存储结构所占存储空间: (A)分两部分,一部分存放结点值,另一部分存放表示结点间关系的指针 2011-2012学年第一学期期末考查 《数据结构》试卷 (答案一律写在答题纸上,在本试卷上做答无效) 一、选择(每题1分,共10分) 1.长度为n的线性表采用顺序存储结构,一个在其第i个位置插入新元素的算法时间复杂度为(D) A.O(0) B.O(1) C.O(n) D.O(n2) 2.六个元素按照6,5,4,3,2,1的顺序入栈,下列哪一个是合法的出栈序列?(D) A.543612 B.453126 C.346512 D.234156 3.设树的度为4,其中度为1、2、3、4的结点个数分别是4、2、1、2,则树中叶子个数为(B ) A.8 B.9 C.10 D.11 4.设森林F对应的二叉树B有m个结点,B的右子树结点个数为n,森林F中第一棵树的结点个数是( B ) A. m-n B.m-n-1 C.n+1 D.m+n 5.若一棵二叉树具有10个度为2的结点,5个度为1的结点,则度为0的结点个数是(B) A.9 B.11 C.15 D.不确定 6.下列哪一个方法可以判断出一个有向图是否有环。(A) A.深度优先遍历 B.拓扑排序 C.求最短路径 D.求关键路径 7.第7层有10个叶子结点的完全二叉树不可能有(B )个结点。 A.73 B.234 C.235 D.236 8.分别用以下序列构造二叉排序树,与用其他三个序列构造的结果不同的是(B) A.(100,80,90,60,120,110,130) B.(100, 120, 110,130,80, 60,90) C.(100,60,80,90,120,110,130) D.(100,80, 60,90, 120, 130,110) 9.对一组数据(84,47,25,15,21)排序,数据的排列次序在排序过程中变化如下:(1)84 47 25 15 21 (2)15 47 25 84 21 (3)15 21 25 84 47(4)15 21 25 47 84则采用的排序方法是(B ) A.选择排序 B.起泡排序 C.快速排序 D.插入排序 10.对线性表进行折半查找时,要求线性表必须(D) A.以顺序方式存储 B.以顺序方式存储,且数据元素有序 一、选择题 1、数据结构在计算机内存中的表示是指____A__ A.数据的存储结构 B.数据结构 C. 数据的逻辑结构 D.数据元素之间的关系 2、若一个算法的时间复杂度用T(n)表示,其中n的含义是( A )A.问题规模 B.语句条数 C.循环层数 D.函数数量 3、下列选项中与数据存储结构无关的术语是( D ) A.顺序表 B.链表 C.链队列 D.栈 4、已知循环队列的存储空间大小为m,队头指针front指向队头元素,队尾指针rear指向队尾元素的下一个位置,则向队列中插入新元素时,修改指针的操作是( D ) =(rear-1)%m; =(front+1)%m; =(front-1)%m; =(rear+1)%m; 5、栈和队列的共同点是__C______ A.都是先进后出 B.都是先进先出 C.只允许在端点处插入和删除元素 D.没有共同点 6、已知一堆栈的进栈序列为1234,则下列哪个序列为不可能的出栈序列______D__ 7、具有线性结构的数据结构是( C ) A.树 B.图 C.栈和队列 D.广义表 8、假设以数组A[60]存放循环队列的元素,其头指针是front=47,当前队列有50个元素,则队列的尾指针值为( B ) A.3 B.37 C.50 D.97 9、若栈采用链式存储结构,则下列说法中正确的是( B ) A.需要判断栈满且需要判断栈空 B.不需要判断栈满但需要判断栈空 C.需要判断栈满但不需要判断栈空 D.不需要判断栈满也不需要判断栈空 10、若一棵具有n(n>0)个结点的二叉树的先序序列与后序序列正好相反,则该二叉树一定是( C ) A.结点均无左孩子的二叉树 B.结点均无右孩子的二叉树 C.高度为n的二叉树 D.存在度为2的结点的二叉树 11、若一棵二叉树中度为l的结点个数是3,度为2的结点个数是4,则该二叉树叶子结点的个数是( B ) 12、在n个结点的线索二叉树中,线索的数目为_C_______ A.n-1 B. n +1 13、一棵完全二叉树有1001个结点,其中有____B_____叶子结点 15、一个有n个顶点的无向图最多有___C____条边。 A. n B. n(n-1) C. n(n-1)/2 D. 2n 16、以v1为起始结点对下图进行深度优先遍历,正确的遍历序列是( D ) 2012年数据结构期末考试题及答案 一、选择题 1.在数据结构中,从逻辑上可以把数据结构分为C。 A.动态结构和静态结构B.紧凑结构和非紧凑结构 C.线性结构和非线性结构D.内部结构和外部结构 2.数据结构在计算机内存中的表示是指A。 A.数据的存储结构B.数据结构C.数据的逻辑结构D.数据元素之间的关系 3.在数据结构中,与所使用的计算机无关的是数据的A结构。 A.逻辑B.存储C.逻辑和存储D.物理 4.在存储数据时,通常不仅要存储各数据元素的值,而且还要存储C。 A.数据的处理方法B.数据元素的类型 C.数据元素之间的关系D.数据的存储方法 5.在决定选取何种存储结构时,一般不考虑A。 A.各结点的值如何B.结点个数的多少 C.对数据有哪些运算D.所用的编程语言实现这种结构是否方便。 6.以下说法正确的是D。 A.数据项是数据的基本单位 B.数据元素是数据的最小单位 C.数据结构是带结构的数据项的集合 D.一些表面上很不相同的数据可以有相同的逻辑结构 7.算法分析的目的是C,算法分析的两个主要方面是A。 (1)A.找出数据结构的合理性B.研究算法中的输入和输出的关系 C.分析算法的效率以求改进C.分析算法的易读性和文档性 (2)A.空间复杂度和时间复杂度B.正确性和简明性 C.可读性和文档性D.数据复杂性和程序复杂性 8.下面程序段的时间复杂度是O(n2)。 s =0; for(I =0;i<n;i++) for(j=0;j<n;j++) s +=B[i][j]; sum =s ; 9.下面程序段的时间复杂度是O(n*m)。 for(i =0;i<n;i++) for(j=0;j<m;j++) A[i][j] =0; 10.下面程序段的时间复杂度是O(log3n)。 i =0; while(i<=n) i =i * 3; 11.在以下的叙述中,正确的是B。 A.线性表的顺序存储结构优于链表存储结构 B.二维数组是其数据元素为线性表的线性表 C.栈的操作方式是先进先出 D.队列的操作方式是先进后出 12.通常要求同一逻辑结构中的所有数据元素具有相同的特性,这意味着B 。 A.数据元素具有同一特点 B.不仅数据元素所包含的数据项的个数要相同,而且对应的数据项的类型要一致 C.每个数据元素都一样 D.数据元素所包含的数据项的个数要相等 13.链表不具备的特点是A。 A.可随机访问任一结点B.插入删除不需要移动元素 C.不必事先估计存储空间D.所需空间与其长度成正比 14.不带头结点的单链表head为空的判定条件是A。 数据结构选择题集锦 单项选择 ( B ) 1. 通常所说的主机是指∶ A) CPU B) CPU和内存C) CPU、内存与外存D) CPU、内存与硬盘 ( C )2. 在计算机内部,一切信息的存取、处理和传送的形式是∶ A) ACSII码B) BCD码C) 二进制D)十六进制 ( D )3. 软件与程序的区别是∶ A)程序价格便宜、软件价格昂贵; B)程序是用户自己编写的,而软件是由厂家提供的; C) 程序是用高级语言编写的,而软件是由机器语言编写的; D) 软件是程序以及开发、使用和维护所需要的所有文档的总称,而程序只是软件的一部分。 ( C )4. 所谓“裸机”是指∶ A) 单片机B)单板机C) 不装备任何软件的计算机D) 只装备操作系统的计算机 ( D )5. 应用软件是指∶ A)所有能够使用的软件 B) 能被各应用单位共同使用的某种软件 C)所有微机上都应使用的基本软件D) 专门为某一应用目的而编制的软件 ( A )6. C语言中的常量可分为整型常量、实型常量、字符型常量及(枚举)四种。 (A)符号常量(B)长整型常量 (C)逻辑常量(D)二进制整数 ( C )7. 编译程序的功能是∶ A)发现源程序中的语法错误 B)改正源程序中的语法错误 C)将源程序编译成目标程序 D)将某一高级语言程序翻译成另一种高级语言 程序 ( A )8. 系统软件中最重要的是∶ A) 操作系统B) 语言处理系统 C) 工具软件D) 数据库管理系统 ( C )9. 可移植性最好的计算机语言是∶ A) 机器语言B)汇编语言C) 高级语言D) 自然语言 ( B )10. 非线性结构是数据元素之间存在一种: A)一对多关系B)多对多关系C)多对一关系D)一对一关系 ( C )11. 数据结构中,与所使用的计算机无关的是数据的结构; A) 存储B) 物理C) 逻辑D) 物理和存储 Java上市公司笔试题目及答案分析 一、选择题(不定项选题) 1下面说法正确的是( C ) A.Java中包的主要作用是实现跨平台功能 B.package语句只能放在import语句后 C.包(package)是由一组类(class) 和接口(inter'face)组成 D.无 2不能用来修饰interface的有(ACD ) Aprivate Bpublic Cprotected Dstatic 3在Java语言中,下列关于字符编码和国际化的叙述,哪些是正确的(CD) A每个中文字符占用2个字节,每个英文字符占用1个字节 B假设数据库中的字符是以GBK编码的,那么显示数据库数据的网页也必须是GBK编码的。 CJava的char类型,通常以UTF-16 Big Endian的方式保存一个字符。 D实现国际化应用常用的手段是利用ResourceBundle类 解析: 1.不同的编码格式,字符所占用的字节数是不一样的。如GBK中每个中文占用2个字 节,UTF-8中则是变长编码,可能占用3个字节或者4个字节。因此A不正确。 2.不同的编码方式之间是可以转换的,如果数据库GBK编码,页面上可以使用任意 支持汉字编码的编码方式显示都可以,只要在向页面传输的数据过程中进行编码的转换即可。如:数据库是GBK,页面上是UTF-8,那么可以这样转换:实例代码以java语法编写 4下面代码的执行结果是(C ) public class TestDemo { public static void main(String[] args) { System.out.println(test1()); 一、选择题。(每小题2分,共40分) (1) 计算机识别.存储和加工处理的对象被统称为____A____。 A.数据 B.数据元素 C.数据结构 D.数据类型 (2) 数据结构通常是研究数据的____ A _____及它们之间的联系。 A.存储和逻辑结构 B.存储和抽象 C.理想和抽象 D.理想与逻辑 (3) 不是数据的逻辑结构是____ A ______。 A.散列结构 B.线性结构 C.树结构 D.图结构 (4) 数据结构被形式地定义为 Questions These questions are intended as a self-test for readers.Answers to the questions may be found in Appendix C. 1.In many data structures you can________a single record,_________it,and _______it. 2.Rearranging the contents of a data structure into a certain order is called _________. 30CHAPTER1Overview 3.In a database,a field is a.a specific data item. b.a specific object. c.part of a recor d. d.part of an algorithm. 4.The field used when searching for a particular record is the______________. 5.In object-oriented programming,an object a.is a class. b.may contain data and methods. c.is a program. d.may contain classes. 6.A class a.is a blueprint for many objects. b.represents a specific real-world object. c.will hold specific values in its fields. d.specifies the type of a method. 7.In Java,a class specification a.creates objects. b.requires the keyword new. c.creates references. d.none of the abov e. 8.When an object wants to do something,it uses a________. 9.In Java,accessing an object’s methods requires the_____operator. 10.In Java,boolean and byte are_____________. (There are no experiments or programming projects for Chapter1.) Questions31 Chapter1,Overview Answers to Questions 1.insert,search for,delete 2.sorting 3.c 4.search key 5.b 6.a 7.d 8.method 《数据结构》期末考试试题及答案 (2003-2004学年第2学期) 单项选择题1、C 2、D 3、A 4、D 5、C 6、D 7、A 8、B 9、C 10、C 一、 1.对于一个算法,当输入非法数据时,也要能作出相应的处理,这种要求称为( c)。 (A)、正确性(B). 可行性(C). 健壮性(D). 输入性 2.设S为C语言的语句,计算机执行下面算法时,算法的时间复杂度为(d )。 for(i=n-1;i>=0;i--) for(j=0;jnext; p->next= Q.front->next; (B)、p=Q.front->next; Q.front->next=p->next; (C)、p=Q.rear->next; p->next= Q.rear->next; (D)、p=Q->next; Q->next=p->next; 9. Huffman树的带权路径长度WPL等于( c ) (A)、除根结点之外的所有结点权值之和(B)、所有结点权值之和 (C)、各叶子结点的带权路径长度之和(D)、根结点的值 好风光好感动1、线性表的逻辑顺序与物理顺序总是一致的。( x ) 2、线性表的顺序存储表示优于链式存储表示。( X ) 3、线性表若采用链式存储表示时所有结点之间的存储单元地址可连续可不连续。( v ) 4、二维数组是其数组元素为线性表的线性表。( v ) 5、每种数据结构都应具备三种基本运算:插入、删除和搜索。( x ) 6、数据结构概念包括数据之间的逻辑结构,数据在计算机中的存储方式和数据的运算三个 方面。( v ) 7、线性表中的每个结点最多只有一个前驱和一个后继。(x ) 8、线性的数据结构可以顺序存储,也可以存储。非线性的数据结构只能存储。(x ) 9、栈和队列逻辑上都是线性表。(v ) 10、单链表从任何一个结点出发,都能访问到所有结点(v ) 11、删除二叉排序树中一个结点,再重新插入上去,一定能得到原来的二叉排序树。(x ) 12、快速排序是排序算法中最快的一种。(x ) 13、多维数组是向量的推广。(x) 14、一般树和二叉树的结点数目都可以为0。(v) 15、直接选择排序是一种不稳定的排序方法。(x ) 16、98、对一个堆按层次遍历,不一定能得到一个有序序列。(v ) 17、在只有度为0和度为k的结点的k叉树中,设度为0的结点有n0个,度为k的结点有nk个,则有n0=nk+1。(x ) 18、折半搜索只适用与有序表,包括有序的顺序表和有序的链表。(x ) 19、堆栈在数据中的存储原则是先进先出。(x ) 20、队列在数据中的存储原则是后进先出。(x ) 21、用相邻矩阵表示图所用的存储空间大小与图的边数成正比。(x ) 22、哈夫曼树一定是满二叉树。(x ) 23、程序是用计算机语言表述的算法。(v) 24、线性表的顺序存储结构是通过数据元素的存储地址直接反映数据元素的逻辑关系。(v ) 25、用一组地址连续的存储单元存放的元素一定构成线性表。(v ) 26、堆栈、队列和数组的逻辑结构都是线性表结构。(v ) 27、给定一组权值,可以唯一构造出一棵哈夫曼树。(x ) 28、只有在初始数据为逆序时,冒泡排序所执行的比较次数最多。(v ) 29、希尔排序在较率上较直接接入排序有较大的改进。但是不稳定的。(v ) 一、单选题(每题 2 分,共20分) 1. 1.对一个算法的评价,不包括如下(B )方面的内容。 A.健壮性和可读性B.并行性C.正确性D.时空复杂度 2. 2.在带有头结点的单链表HL中,要向表头插入一个由指针p指向的结 点,则执行(A )。 A. p->next=HL->next; HL->next=p; B. p->next=HL; HL=p; C. p->next=HL; p=HL; D. HL=p; p->next=HL; 3. 3.对线性表,在下列哪种情况下应当采用链表表示?( B ) A.经常需要随机地存取元素 B.经常需要进行插入和删除操作 C.表中元素需要占据一片连续的存储空间 D.表中元素的个数不变 4. 4.一个栈的输入序列为1 2 3,则下列序列中不可能是栈的输出序列的是 ( C ) A. 2 3 1 B. 3 2 1 C. 3 1 2 D. 1 2 3 5. 5.AOV网是一种(D )。 A.有向图B.无向图C.无向无环图D.有向无环图 6. 6.采用开放定址法处理散列表的冲突时,其平均查找长度(B)。 A.低于链接法处理冲突 B. 高于链接法处理冲突 C.与链接法处理冲突相同D.高于二分查找 7.7.若需要利用形参直接访问实参时,应将形参变量说明为(D )参数。 A.值B.函数C.指针D.引用 8.8.在稀疏矩阵的带行指针向量的链接存储中,每个单链表中的结点都具 有相同的( A )。 A.行号B.列号C.元素值D.非零元素个数 9.9.快速排序在最坏情况下的时间复杂度为(D )。 A.O(log2n) B.O(nlog2n) C.0(n) D.0(n2) 10.10.从二叉搜索树中查找一个元素时,其时间复杂度大致为( C )。 A. O(n) B. O(1) C. O(log2n) D. O(n2) 二、运算题(每题 6 分,共24分) 1. 1.数据结构是指数据及其相互之间的______________。当结点之间存在M 对N(M:N)的联系时,称这种结构为_____________________。 2. 2.队列的插入操作是在队列的_ _尾______进行,删除操作是在队列的____ 首______进行。 3. 3.当用长度为N的数组顺序存储一个栈时,假定用top==N表示栈空,则 表示栈满的条件是___top==0___(要超出才为满)_______________。 4. 4.对于一个长度为n的单链存储的线性表,在表头插入元素的时间复杂度 为_________,在表尾插入元素的时间复杂度为____________。 一、单选题(每题2分,共30分) 1.以下数据结构中,()是非线性数据结构。 A.树 B.字符串 C.队 D.栈 2.下面算法的时间复杂度为() int f(int n) if (n==0 || n==1) return 1; else return n * f(n-1); A.O(1) B.O(n) C.O(n的平方) D.O(n!) 3.下述哪一条是Array这种数据结构的优点?() A.存储密度大 B.插入运算方便 C.删除运算方便 D.可方便地用于各种逻辑结构的存储表示 4.下面关于字符串的叙述中,哪一个是不正确的?() A.串是字符的有限序列 B.空串是由空格构成的串 C.模式匹配是字符串的一种重要运算 D.串既可以采用顺序存储,也可采用链式存储5.在无序数组中,允许重复会导致()。 A.所有操作时间都会增加 B.总会增加插入时间 C.在某些情况下查找时间的增加 D.有时会减少插入时间 6.若某数据结构最常用的操作是存取任一指定序号的元素和在尾部进行插入和删除运算,则利用()存储方式最节省时间。 A.Array B.双链表 C.带头结点的双循环链表 D.单循环链表 7.非空的循环单链表的尾结点p满足()。 A.p.next==first B.p.next == null C.p == null D.p == first 8.在单链表指针为p的结点之后插入指针为s的结点,正确的操作是:() A.p.next = s; s.next = p.next; B.s.next = p.next;p.next = s; C.p.next = s; p.next = s.next; D.p.next = s.next; p.next = s; 9.有六个元素6,5,4,3,2,1.顺序进栈。问下列哪一个不是合法的出栈序列?() A.5 4 3 6 1 2 B.4 5 3 1 2 6 C.3 4 6 5 2 1 D.2 3 4 1 5 6 10.在Hanoi塔问题中,若A塔上有3片圆盘。都要搬到C塔上去。则下列语句()是错误的。 11.归并排序的主要缺点是()。 A.没有递归 B.使用更多的存储空间 C.尽管比插入算法快,但是它比快速排序慢得多 D.需要7次才能完成工作 12.树最适合用来表示() A.有序数据元素 B.无序数据元素 C.元素之间具有分支层次关系的数据 D.元素之间无联系的数据 13.引入二叉树的主要目的是() A.加快查找结点的前驱或后继的速度 B.能较快地进行插入与删除 C.为了能方便的找到双亲 D.使遍历的结果唯一 14.要连通具有N个顶点的有向图,至少需要()条边。 A.n-1 B.n C.n+1 D.2n 数据结构试卷(一) 二、填空题(每空1分,共26分) 1.通常从四个方面评价算法的质量:_________、_________、_________和_________。 2.一个算法的时间复杂度为(n3+n2log2n+14n)/n2,其数量级表示为________。 3.假定一棵树的广义表表示为A(C,D(E,F,G),H(I,J)),则树中所含的结点数 为__________个,树的深度为___________,树的度为_________。 4.后缀算式9 2 3 +- 10 2 / -的值为__________。中缀算式(3+4X)-2Y/3对应的后缀算式 为_______________________________。 5.若用链表存储一棵二叉树时,每个结点除数据域外,还有指向左孩子和右孩子的两个指 针。在这种存储结构中,n个结点的二叉树共有________个指针域,其中有________个指针域是存放了地址,有________________个指针是空指针。 6.对于一个具有n个顶点和e条边的有向图和无向图,在其对应的邻接表中,所含边结点 分别有_______个和________个。 7.AOV网是一种___________________的图。 8.在一个具有n个顶点的无向完全图中,包含有________条边,在一个具有n个顶点的有 向完全图中,包含有________条边。 9.假定一个线性表为(12,23,74,55,63,40),若按Key % 4条件进行划分,使得同一余数的元 素成为一个子表,则得到的四个子表分别为____________________________、___________________、_______________________和__________________________。 10.向一棵B_树插入元素的过程中,若最终引起树根结点的分裂,则新树比原树的高度 ___________。 11.在堆排序的过程中,对任一分支结点进行筛运算的时间复杂度为________,整个堆排序 过程的时间复杂度为________。 12.在快速排序、堆排序、归并排序中,_________排序是稳定的。 三、计算题(每题6 分,共24分) 1.在如下数组A中链接存储了一个线性表,表头指针为A [0].next,试写出该线性表。 A 0 1 2 3 4 5 6 7 data 60 50 78 90 34 40 next 3 5 7 2 0 4 1 2.请画出下图的邻接矩阵和邻接表。 3.已知一个图的顶点集V和边集E分别为:V={1,2,3,4,5,6,7}; E={(1,2)3,(1,3)5,(1,4)8,(2,5)10,(2,3)6,(3,4)15, (3,5)12,(3,6)9,(4,6)4,(4,7)20,(5,6)18,(6,7)25}; 用克鲁斯卡尔算法得到最小生成树,试写出在最小生成树中依次得到的各条边。 4.画出向小根堆中加入数据4, 2, 5, 8, 3时,每加入一个数据后堆的变化。 四、阅读算法(每题7分,共14分) 1.LinkList mynote(LinkList L) {//L是不带头结点的单链表的头指针 if(L&&L->next){ q=L;L=L->next;p=L; S1:while(p->next) p=p->next; 一、填空题 1. 栈和队列的共同特点是(只允许在端点处插入和删除元素)。 2. 在深度为5的满二叉树中,叶子结点的个数为(31) 3. 算法分析的目的是(分析算法的效率以求改进)。 4. 由两个栈共享一个存储空间的好处是(节省存储空间,降低上溢发生的机率)。 5.串的长度是(串中所含字符的个数)。 6.设有两个串p和q,求q在p中首次出现位置的运算称做(模式匹配) 7. N个顶点的连通图中边的条数至少为(N-1)。 8.N个顶点的强连通图的边数至少有(N)。 9.对长度为n的线性表进行顺序查找,在最坏情况下所需要的比较次数为(N)。P259 10.假设线性表的长度为n,则在最坏情况下,冒泡排序需要的比较次数为(n(n-1)/2)。P292 11. 在n个结点的单链表中要删除已知结点*p,需找到它的前驱结点的地址,其时间复杂度为O(n)。 12. 在具有n个单元的循环队列中,队满时共有n-1 个元素。 13. 有向图G用邻接表矩阵存储,其第i行的所有元素之和等于顶点i的出度。 14. 用Dijkstra算法求某一顶点到其余各顶点间的最短路径是按路径长度递增的次序来得到最短路径的。 15. 在图形结构中,每个结点的前驱结点数和后续结点数可以任意多个。 16.在一个循环队列中,队首指针指向队首元素的前一个位置。17.在顺序表中插入或删除一个元素,需要平均移动表中一半元素,具体移动的元素个数与表长和该元素在表中的位置有关。 18. 线性表中结点的集合是有限的,结点间的关系是一对一的。 19.数据结构被形式地定义为(D, R),其中D是数据元素的有限集合,R是D上的关系有限集合。 20. 线性结构中元素之间存在一对一关系,树形结构中元素之间存在一对多关系,图形结构中元素之间存在多对多关系。 21. 一个算法的效率可分为时间效率和空间效率。 22. 在顺序表中访问任意一结点的时间复杂度均为O(1) ,因此,顺序表也称为随机存取的数据结构。 23. 在n个结点的单链表中要删除已知结点*p,需找到它的前驱结点的地址,其时间复杂度为O(n)。 24. 在具有n个单元的循环队列中,队满时共有n-1 个元素。 25. 对于栈只能在栈顶插入和删除元素;对于队列只能在队尾插入和队首删除元素。 26. 一棵深度为6的满二叉树有n1+n2=0+ n2= n0-1=31 个分支结点和26-1 =32 个叶子。 27. 有向图G用邻接表矩阵存储,其第i行的所有元素之和等于顶点i的出度。 《数据结构》题库及答案 一、选择题 1.线性表的顺序存储结构是一种的存储结构,线性表的链式存储结构是一种的存储结构。 a.随机存储; b.顺序存储; c. 索引存取; d. HASH存取 2.一个栈的入栈序列是a,b,c,d,e,则栈的不可能的输出序列是。 a. edcba; b. decba; c. dceab; 3.一个队列的入队序列是1,2,3,4,则队列的输出序列是。 a. 4,3,2,1; b. 1,2,3,4; c. 1,4,3,2; ,2,4,1 ¥ 4.在一个单链表中,已知p结点是q结点的直接前驱结点,若在p和q之间插入结点s,则执行的操作是。 a.s->nxet=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; 5.设有两个串p,q,求q在p中首次出现的位置的运算称作。 a.联接 b.模式匹配 c.求子串 d.求串长 6.二维数组M的成员是6个字符(每个字符占一个存储单元)组成的串,行下标i的范围从0到8,列下标j 的范围从1到10,则存放M至少需要个字节。 a.、 b.90 7.在线索二叉树中,结点p没有左子树的充要条件是。 a.p->lch==NULL b.p->ltag==1 c.p->ltag==1且p->lch=NULL d.以上都不对 8.在栈操作中,输入序列为(A,B,C,D),不可能得到的输出序列为:______ A、(A,B,C,D) B、(D,C,B,A) * C、(A,C,D,B) D、(C,A,B,D) 9.已知某二叉树的后序序列是dabec,中序序列是debac,则它的先序序列是。 A、acbed B、decab C、deabc D、cedba 10.设矩阵A是一个对称矩阵,为了节省存储空间,将其下三角部分(见下图)按行序存放在一维数组数据结构-第六章-图-练习题及答案详细解析(精华版)
面试时的Java数据结构与算法
数据结构复习资料,java数据结构期末考试
数据结构选择题集锦
《数据结构》期末考试题及答案
数据结构(java)复习题及答案
2015年数据结构期末考试题及答案
数据结构选择题集锦
java笔试题目及答案分析
数据结构复习题及答案(12级).
JAVA数据结构习题及解答(英)
《数据结构》期末考试试题及答案
数据结构试题及答案
数据结构试题及答案(10套最新)
2009Java数据结构考题
十套数据结构试题及答案
数据结构总复习题(JAVA)
《数据结构》题库及答案