試題1：圖兩點最短距離
網圖中兩點之間的最短距離可以通過Dijkstra算法進行計算，通過該算法能夠計算出從源點到該圖所有頂點的最短距離，給你的問題是：通過DSjar.jar歸檔文件提供的使用鄰接矩陣存儲的圖對象，計算圖中任意兩頂點之間的最短距離和路徑。 利用類庫中的MGraph的參考代碼如下：
MGraph mg=new MGraph();//創建的圖已經實例化了該圖的鄰接矩陣，你可以通過輸出該矩陣進行查看
輸入：標準輸入，輸入一行有兩個正整數，分別表示起點和終點的兩個頂點的序號，如果網圖有5個頂點，序號從0到4。
輸出：標準輸出，輸出格式爲"A-->E distance 90path:A-->B-->E",其中，A爲源點頂點名，E爲終點頂點名，90爲A到E的最短距離，A-->B-->E爲路徑。
測試用例輸入：
0 4
測試用例輸出：
A-->E distance 90 path:A-->B-->E
importjava.util.Scanner;
importjava.util.Stack;
importhhxy.jsj.graphic.MGraph;
public classMyDijkstra {
private final static intMAXSIZE=10000;
public static voidmain(String[] args) {
// TODO Auto-generated method stub
MGraph g=new MGraph(7,10,false);
Scanner in=newScanner(System.in);
int[] p=new int[7];
int[] d=new int[7];
int i=in.nextInt();
int j=in.nextInt();
GraphTool.shortestpath(g,p,d,i);
GraphTool.pntshortestpath(g,p,d,i,j);
}
}
classGraphTool {
private final static intMAXSIZE=10000;
public static voidshortestpath(MGraph g, int[] p, int[] d, int i) {
// TODO Auto-generated method stub
int[] flag=new int[g.vexnum];
p[i]=-1;flag[i]=1;d[i]=0;
for(intk=0;k<g.vexnum;k++){
if(k!=i){
d[k]=g.edges[i][k];
p[k]=i;
}
}
for(intn=1;n<g.vexnum;n++){
intmin=MAXSIZE;
int j=0;
for(intk=0;k<g.vexnum;k++){
if(flag[k]==0&&d[k]<min){
min=d[k];
j=k;
}
}
flag[j]=1;
for(intk=0;k<g.vexnum;k++){
if((flag[k]==0)&&(min+g.edges[j][k])<d[k]){
d[k]=min+g.edges[j][k];
p[k]=j;
}
}
}
}
public static voidpntshortestpath(MGraph g, int[] P, int[] D, int i, intj){
Stack<Integer> st=newStack<Integer>();
System.out.print(g.vexs[i].vname+"-->:"+g.vexs[j].vname+"diatance "+D[j]+" path:");
int k=j;
while(P[k]!=-1){//將數組數據壓站
st.push(P[k]);
k=P[k];
}
while(!st.isEmpty()){
k=st.pop();
System.out.print(g.vexs[k].vname+"-->");
}
System.out.println(g.vexs[j].vname);
}
}
試題2：圖的存儲實現
圖的存儲方式有鄰接矩陣和鄰接表兩種基本存儲方式，通過給你提供一個圖的鄰接矩陣存儲對象，該對象的鄰接矩陣已經賦值;請你將該圖的鄰接矩陣轉換爲鄰接表存儲的圖對象，圖的對象類型在提供給你的DSjar.jar歸檔文件中;你可以利用提供的庫對象完成本題目的操作，在創建鄰接表時，要求從編號小到大的頂點的邊進行後插入，如果是無向圖，也同樣從編號小的頂點到編號大的頂點連接的邊進行尾部插入。在MGraph對象中，已經存儲了圖的相關信息，創建該對象的方法如下：
MGraph mg=new MGraph();
通過該對象可以獲得圖的頂點、邊等信息，然後利用獲得的信息新建一個鄰接表圖對象。調用圖對象的打印方法（pntALGraph()）實現圖的存儲信息的輸出。
流程控制如下：
MGraph mg=new MGraph();//創建鄰接矩陣對象
int vexnum=mg.vexnum;//獲得頂點數目
int edgenum=mg.edgenum;//獲得邊數目
boolean isdirection =mg.isdirection;//是否爲有向圖
ALGraph alg=new ALGraph(vexnum,edgenum,isdirection);//創建鄰接表圖對象
//給頂點結點數組賦值
for(int i=0;i<vexnum;i++){
alg.vextex[i]=new VexNode(mg.vexs[i]);
}
EdgeNode p=null;
//建立鄰接表邊鏈表
for(int i=0;i<vexnum;i++){
for(int j=0;j<vexnum;j++){
int w=mg.edges[i][j];
if(w>0&&w<1000){
//使用尾插入建立單鏈表代碼
}
}
}
//輸出鄰接表圖存儲示例圖
alg.pntALGraph();
輸入：沒有輸入。
輸出：輸出圖的鄰接表，依據頂點的次序每行輸出一個頂點的鄰接表信息。
測試用例：
輸入：無
輸出（僅參考，非正確結果）：
1-->[1,20,^]
2-->[2,45,-]-> [0,23,^]
3 ^
importhhxy.jsj.graphic.MGraph;
import hhxy.jsj.graphic.Vex;
public class ALGraph {
public static voidmain(String[] args){
MGraph mg=new MGraph(7,10,false);
int vexnum=mg.vexnum;
int edgenum=mg.edgenum;
boolean isdirection =mg.isdirection;
tALGraph alg=new tALGraph(vexnum,edgenum,isdirection);
for(int i=0;i<vexnum;i++){
alg.vextex[i]=new VexNode(mg.vexs[i]);
}
EdgeNode p=null;
for(int i=0;i<vexnum;i++){
for(int j=0;j<vexnum;j++){
int w=mg.edges[i][j];
if(w>0&&w<1000){
p=alg.vextex[i].firstedge;
if(p==null){
alg.vextex[i].firstedge=new EdgeNode(j,w);
}else{
while(p.next!=null)p=p.next;
p.next=new EdgeNode(j,w);
}
}
}
}
alg.pntGraph();
}
}
class tALGraph{
VexNode[] vextex;
int vexnum;
int edgenum;
boolean isdirection;
EdgeNode p;
public tALGraph(int vexnum,int edgenum,boolean isdirection){
this.vexnum = vexnum;
this.edgenum = edgenum;
this.isdirection = isdirection;
vextex=new VexNode[vexnum];//分配空間
}
public void pntGraph(){
for(int i=0;i<vexnum;i++){
System.out.print(i);//輸出頂點名
//完善代碼 輸出每個頂點的鏈表
p=vextex[i].firstedge;
int n=0;
while(p!=null){
if(n==0)
System.out.print("-->["+p.adjvexindex+","+p.data+",");
else
System.out.print("-]->["+p.adjvexindex+","+p.data+",");
p=p.next;
n++;
}
if(n!=0){
System.out.println("^]");
}else{
System.out.println("^");
}
}
}
}
class VexNode {
hhxy.jsj.graphic.Vex vex;
EdgeNode firstedge;//頂點的鄰接邊
VexNode(hhxy.jsj.graphic.Vex vexs){
this.vex=vexs;
firstedge=null;//wei kong
}
}
class EdgeNode {
int adjvexindex;//鄰接頂點的序號
int data;//邊的權值
EdgeNode next;
public EdgeNode(int adj,int data){//i,j,w
next=null;
adjvexindex=adj;//j
this.data = data;//w
}
}
試題1：哈夫曼樹的實現
哈夫曼樹也稱爲最優二叉樹，是指對於一組有確定權值的葉結點、構造的具有最小帶權路徑長度的二叉樹。給你的問題是，提供一組n個整數權值，請你完成構建該組權值的哈夫曼樹。
輸入：標準輸入，輸入的第一行爲一個正整數，其值代表需要構建二叉樹的葉結點的個數n;輸入的第二行爲n個由一個空格隔開的正整數，表示葉結點的權值；輸入的第三行爲n個字符，對應第二行的權值的葉結點的名稱；
輸出：標準輸出，輸出構建的哈夫曼樹的每個葉結點的訪問路徑，即從根到葉結點的路徑，如果是走左輸出l,如果走右輸出r。每行輸出一個葉結點信息，輸出格式爲:先輸出該結點的名稱，再輸出冒號，接下來，輸出路徑，中間僅一個空格隔開。按照輸入葉結點的名稱次序分別使用n行輸出。
測試樣例：
輸入：
4
7 5 3 1
abcd
輸出：
a:l
b:r r
c:r l r
d:r l l
說明，爲了進行系統判斷，在構建哈夫曼樹時，要求：
（1）選擇兩個權值小的結點在構建子樹時，小的結點爲左子樹，較大的爲右子樹；
（2）如果存在兩個權值相同，以出現的順序依次爲左右子樹；
提示：
在構建哈夫曼樹時，提供設計的結點對象參考如下：
public class HFMTreeNode {
int weight,parent,lchild,rchild;
HFMTreeNode(){
weight=0;
parent=lchild=rchild=-1;
}
}
public class HFMTool {
public static voidmain(String[] args){
Scanner in=new Scanner(System.in);
int l=in.nextInt();
int[] weight=new int[l];
for(int i=0;i<l;i++){
weight[i]=in.nextInt();
}
String string=in.next();
char[] ch1=string.toCharArray();
int n=ch1.length;
HFMTreeNode[] hfmtree=new HFMTreeNode[2*n-1];
for(int i=0;i<2*n-1;i++)hfmtree[i]=new HFMTreeNode();
for(int i=0;i<n;i++)hfmtree[i].weight=weight[i];
createHFMTree(hfmtree,n);
HFMCodeNode[] hfmcd=new HFMCodeNode[n];
for(int i=0;i<n;i++)hfmcd[i]=new HFMCodeNode(n);
createHFMCode(hfmtree,hfmcd);
for(int i=0;i<n;i++){
System.out.print(ch1[i]+": ");
for(int j=hfmcd[i].start+1;j<n;j++){
if(hfmcd[i].bit[j]==0)
System.out.print("l ");
else
System.out.print("r ");
}
System.out.println();
}
}
public static void createHFMCode(HFMTreeNode[]hfmtree,HFMCodeNode[] cd){
int n=cd.length;
for(int i=0;i<n;i++){
int c=i;
int p=hfmtree[i].parent;
while(p!=-1){
if(hfmtree[p].lchild==c){
cd[i].bit[cd[i].start]=0;
}else if(hfmtree[p].rchild==c){
cd[i].bit[cd[i].start]=1;
}
cd[i].start--;
c=p;
p=hfmtree[c].parent;
}
}
}
public static voidcreateHFMTree(HFMTreeNode[] hfmtree,int n){
int x1,x2;
int m1,m2;
for(int i=0;i<n-1;i++){
x1=x2=10000;
m1=m2=0;
for(int j=0;j<n+i;j++){
if(hfmtree[j].parent==-1 && hfmtree[j].weight<x1){
x2=x1;
m2=m1;
x1=hfmtree[j].weight;
m1=j;
}else if(hfmtree[j].parent==-1 && hfmtree[j].weight<x2){
x2=hfmtree[j].weight;
m2=j;
}
}
hfmtree[n+i].weight=x1+x2;
hfmtree[n+i].lchild=m1;
hfmtree[n+i].rchild=m2;
hfmtree[m1].parent=n+i;
hfmtree[m2].parent=n+i;
}
}
}
class HFMTreeNode {
int weight,parent,lchild,rchild;
HFMTreeNode(){
weight=0;
parent=lchild=rchild=-1;
}
}
class HFMCodeNode {
int[] bit;
int start;
HFMCodeNode(int n){
bit=new int[n];
start=n-1;
}
}
試題2：二叉樹的遍歷
給你一顆已經創建完成的二叉樹，請你根據要求完成該樹的遍歷實現。提供給你的使用歸檔文件DSjar.jar，該文件包含了二叉樹需要使用的類型和棧隊列等相關類型，並提供了一個創建樹的靜態方法，你可以使用該類庫來創建樹並完成樹的遍歷，遍歷代碼需要你自己設計完成，能提供你的僅爲一個創建好的二叉樹，二叉樹的節點數據類型爲Character,該樹的創建代碼如下：
LinkBiTree<Character> tree =new LinkBiTree<Character>();
LinkBiTree.create(tree);
你通過提供的引用tree完成該樹的遍歷，遍歷可以使用遞歸和非遞歸實現。建議你在創建的對象文件中定義如下4種遍歷的靜態方法，然後根據需要進行調用：
static void PreOrder(LinkBiTree<Character> tree){ //先序遍歷
}
static void InOrder(LinkBiTree<Character> tree){ //中序遍歷
}
static void PostOrder(LinkBiTree<Character> tree){ //後序遍歷
}
static void levelOrder(LinkBiTree<Character> tree){//層次遍歷
}
輸入：標準輸入，輸入爲由一個空格分隔開的4個整數，其中1表示先序遍歷，2表示中序遍歷，
3表示後序遍歷，4表示分層遍歷。
輸出：標準輸出，根據輸入的要求，各種遍歷使用一行輸出，每個頂點的數據爲字符，字符之間使用
一個空格分開。
測試用例：
輸入：
1 2 3 4
輸出（非正確輸出，僅參考格式）：
A B C
B A C
B C A
A B C
public classBiTreeSearch {
public static voidmain(String[] args) {
int[] a=new int[4];
LinkBiTree<Character> tree =newLinkBiTree<Character>();
LinkBiTree.create(tree);
Scanner in=newScanner(System.in);
for(int i=0;i<4;i++){
a[i]=in.nextInt();
}
for(int i=0;i<4;i++){
int j=a[i];
switch(j){
case 1:PreOrder(tree.root);break;
case 2:InOrder(tree.root);break;
case 3:PostOrder(tree.root);break;
case 4:levelOrder(tree.root);break;
}
System.out.println();
}
}
static void PreOrder(LinkNodep){ //先序遍歷
if(p==null)return;
System.out.print(p.data+"");
PreOrder(p.lchild);
PreOrder(p.rchild);
}
static void InOrder(LinkNodep){ //中序遍歷
if(p==null) return;
InOrder(p.lchild);
System.out.print(p.data+"");
InOrder(p.rchild);
}
static void PostOrder(LinkNodep){ //後序遍歷
if(p==null)return;
PostOrder(p.lchild);
PostOrder(p.rchild);
System.out.print(p.data+"");
}
static<E> voidlevelOrder(LinkNode root){//層次遍歷
if(root==null)return;
Queue<LinkNode<E>> q=newLinkedList<LinkNode<E>>();
q.add(root);
while(!q.isEmpty()){
LinkNode<E> p=q.poll();
System.out.print(p.data+"");
if(p.lchild!= null){
q.add (p.lchild);
}
if(p.rchild!= null){
q.add (p.rchild);
}
}
}
}
classLinkBiTree<E>{
LinkNode<E> root=null;
public static voidcreate(LinkBiTree<Character> tree){
tree.create('A', null, null);
tree.insertL(tree.root, newLinkNode('B'));
tree.insertR(tree.root, newLinkNode('C'));
}
public void create(E val,LinkNode<E> l, LinkNode<E> r) {
root = new LinkNode(val,l,r);
}
public voidinsertL(LinkNode<E> node, LinkNode<E> p) {
if(node!=null){
node.lchild = p;
}
}
public voidinsertR(LinkNode<E> node, LinkNode<E> p) {
if(node!=null){
node.rchild = p;
}
}
}
classLinkNode<E>{
E data;
LinkNode<E> lchild,rchild;
LinkNode(E data,LinkNode<E>l,LinkNode<E> r){
this.data =data;
this.lchild = l;
this.rchild = r;
}
LinkNode(E data){
this.data =data;
this.lchild = null;
this.rchild = null;
}
}
試題1：折半查找
折半查找是在有序表中，把待查找數據值與查找範圍的中間元素值進行比較，會有三種情況出現：
1）待查找數據值與中間元素值正好相等，則放回中間元素值的索引。
2）待查找數據值比中間元素值小，則以整個查找範圍的前半部分作爲新的查找範圍，執行1），直到找到相等的值。
3）待查找數據值比中間元素值大，則以整個查找範圍的後半部分作爲新的查找範圍，執行1），直到找到相等的值
4）如果最後找不到相等的值，則返回不存儲數據的備用單位0。
給你的問題是，標準輸入一升序排列有序整數表，使用折半查找方法查找一個給定的整數值，查找中是通過使用表中的元素與給定的元素值進行比較完成查找，需要你依次輸出在折半查找過程中使用過比較的元素值。
輸入：標準輸入，輸入的第一行爲一個正整數n，表示需要查找表的元素個數；第二行爲具有升序序列的n個整數，兩數之間爲一個空格隔開；第三行爲需要你查找的整數。
輸出：標準輸出，第一行依次輸出在查找過程中進行比較的元素值，兩數之間使用一個空格隔開。輸出的第二行輸出查找結果，如果查找元素在表中，輸出該元素的序號（從1開始編號），如果查找元素不在表中，輸出“NO"。
輸入樣例：
13
7 14 18 21 23 29 31 35 38 42 46 49 52
21
輸出樣例：
31 18 23 21
4
public classZebanchazhao {
public static voidmain(String[] args) {
int n,l;
int []data;
Scanner in=newScanner(System.in);
n=in.nextInt();
data=new int [n];
for(int i=0;i<n;i++)data[i]=in.nextInt();
l=in.nextInt();
System.out.println(binSearch(data,l));
}
privatestatic int binSearch(int[] data,int key) {
int low =0,high=data.length-1,mid;
while(high>=low){
mid=(low+high)/2;
System.out.print(data[mid]+"");
if(key==data[mid]){
System.out.println();
return mid+1;
}else if(key>data[mid])
low=mid+1;
else high=mid-1;
}
System.out.println();
return 0;
}
}
試題2：堆排序
堆排序的思想實際上利用完全二叉樹存儲在數組中，通過調整完全二叉樹成爲大頂堆獲得一個排序表的最大值進行排序的方法，大頂堆滿足根節點比子樹旳節點大。堆排序主要是通過大頂堆旳根元素與未完成排序旳最後一個元素進行交換，將交換後旳完全二叉樹不滿足大頂堆要求調整到滿足滿足要求，調整通過如下方法完成：
void heapAdjust(int[] R,int s,int t);其中，數組R中存儲旳二叉樹，只有以R[s]爲根子樹，其左右子樹之間可能不滿足大頂堆特徵。
調整堆旳操作難點爲根子樹節點編號爲i,則左子樹節點編號爲2*i，右子樹節點編號爲2*i+1;通過比較子樹旳大小選擇大旳子樹進行調整，一直調整到根節點比子節點大，再將根節點旳值插入到最後調整旳節點。要完成堆排序，在調整旳基礎上可以通過從堆底往堆頂進行調整獲得初始堆，然後通過N-1次調整完成排序，控制流程爲：
void heapSort(int[] R){
int i;
int N=R.length-1;
for(i=N/2;i>0;i--){
heapAdjust(R,i,N);
}
for(i=N;i>1;i--){
R[0]=R[1]；R[1]=R[i]；R[i]=R[0];
heapAdjust(R,1,i-1);
}
}
給你旳問題是，將標準輸入的n個整數採用堆排序，並需要顯示建成旳初始堆，並完成該數據的排序。
輸入：標準輸入，輸入的第一行爲整數的個數n值，第二行爲n個整數，每個整數之間爲一個空格。
輸出：標準輸出，第一行依次輸出排序過程中建成旳初始堆在數組中的存儲值，每個輸出數據之間使用一個空格隔開，第二行輸出排序後的序列，每個輸出數據之間使用一個空格隔開。
輸入樣例：
14
39 80 76 41 13 29 50 78 30 11 100 7 41 86
輸出樣例：
100 80 86 78 39 41 76 41 30 11 13 7 29 50
7 11 13 29 30 39 41 41 50 76 78 80 86 100
public classdui {
public static voidmain(String[] args) {
int n;int[] data;
Scanner in=new Scanner(System.in);
n=in.nextInt();
data=new int[n];
for(int i=0;i<n;i++)
data[i]=in.nextInt();
heapSort(data,0,data.length-1);
for(int i=0;i<n;i++)
System.out.print(i!=n-1?data[i]+"":data[i]);
System.out.println();
in.close();
}
public static voidheapSort(int[] data,int low,int high){
int i,top;
int N=data.length-1;
for(i=N/2;i>=0;i--){//創建初始堆
siftdown(data,i,N);
}
for(i=0;i<=N;i++)
System.out.print(i!=N?data[i]+"":data[i]);
System.out.println();
for(i=N;i>0;i--){
//取出堆頂元素放在數組的最後面，數組最後的數放在堆頂再向下調整，數組的0位置不用來存儲堆數據，用來交換數據的時候暫存數據
top=data[0];
data[0]=data[i];
data[i]=top;
siftdown(data,0,i-1);
}
}
public static voidsiftdown(int[] data,int low,int high){
intk=low;
intj=2*k+1;
inttemp=data[k];
while(j<=high){
//判斷右子節點是否存在，並比較左右節點的大小，和最大的交換
if((j<high)&&(j+1<=high)&&(data[j]<data[j+1]))
++j;
if(temp<data[j]){//調整完之後繼續向下調整
data[k]=data[j];
k=j;
j=2*k+1;
}else{
break;
}
}
data[k]=temp;//找到該點的合適位置
}
}
- 試題1：快速排序
快速排序的核心操作是劃分，通過某個數據將原來排序表分成兩部分，前面部分比該數小，後面數據比該數據大或相等，該位置就爲某數據排序後的位置，即該數據完成排序。如果定義一個排序表的劃分方法爲：
int partition(int[] R,int low,int high); 其中，low,high表示將數據R的第low個數據到high個數據進行劃分，返回到整數爲劃分後到支點存儲的位置；快速排序在查找分支點位置的方法有多種，本題目的排序過程中，首先從右向左移動，搜索小於分支記錄的第一個元素，再從左向右移動，搜索大於分支記錄的第一個元素，交互該兩個記錄值，繼續搜索，直到兩個搜索點交匯，如果交匯點記錄與分支記錄相等，分支記錄與交匯點數據不交換，分支位置爲交匯位置; 完成劃分方法後，通過遞歸調用完成快速排序：
void QuickSort(int[] R,int s,int t){
if(s<t){
int i=partition(R,s,t);
QuickSort(R,s,i-1);
QuickSort(R,i+1,t);
}
}
建議每次劃分選擇第一個元素爲支點記錄進行編程。給你到問題是，將標準輸入的n個整數採用快速排序，並需要顯示出每次劃分分支點存儲的位置，第一個數爲0，分支點的輸出順序按照程序遞歸產生的分支點的先後進行輸出，並完成該數據的排序。
輸入：標準輸入，輸入的第一行爲整數的個數n值，第二行爲n個整數，每個整數之間爲一個空格。
輸出：標準輸出，輸出的第一行依次輸出排序過程中使用的支點位置，每個輸出數據之間使用一個空格隔開,第二行輸出排序後的序列，每個輸出數據之間使用一個空格隔開。
輸入樣例：
14
39 80 76 41 13 29 50 78 30 11 100 7 41 86
輸出樣例：
5 3 2 1 8 7 9 13 12 10
7 11 13 29 30 39 41 41 50 76 78 80 86 100
public classQuicksort {
public static voidmain(String[] args) {
int n;int[] data;
Scanner in=newScanner(System.in);
n=in.nextInt();
data=new int[n];
for(int i=0;i<n;i++)
data[i]=in.nextInt();
QuickSort(data,0,data.length-1);
System.out.println();
for(int i=0;i<n;i++)
System.out.print(data[i]+"");
System.out.println();
}
public static voidQuickSort(int[] R,int low,int high){
int base=R[low];
int i=low+1;
int j=high;
int temp;
while(i<j){
while((i<j)&&(R[j]>=base))
--j;
while((i<j)&&(R[i]<=base))
++i;
if(i<j){
temp=R[i];
R[i]=R[j];
R[j]=temp;
}
}
if(i==low+1&&R[i]>R[low]){
i=low;
j=low;
}
if(R[j]<=R[low]){
temp=R[low];
R[low]=R[j];
R[j]=temp;
}
System.out.print(j+"");
if(i-low>1)
QuickSort(R,low,i-1);
if(high-j>1)
QuickSort(R,j+1,high);
}
}
試題2：希爾排序
希爾排序的思想是：先選擇一個小於排序數據個數n的整數di(稱爲步長，一般爲小於n的質數），將間隔di的數爲一組，對每組的元素進行直接插入排序，即將需要排序的數據插入到已經排序好的序列中。當步長爲1時，完成整個數據的排序。排序的流程爲：
1、根據步長的個數，對於每個步長進行分組；
2、對每組進行插入排序，主要操作如下：
1）如果待插入數據比前一個數據小，將該數據存儲到臨時遍歷temp中；
2）將前面比他大的數據全部向後移動一位；
3）再將temp的數據插入到最後移動的數據位置；
給你到問題是，將標準輸入的n個整數採用希爾排序，步長取5，3，1，並需要顯示出每次需要插入的數，並完成該數據的排序。
輸入：標準輸入，輸入的第一行爲整數的個數n值，第二行爲n個整數，每個整數之間爲一個空格。
輸出：標準輸出，輸出第一行依次輸出排序過程中需要插入的數，每個輸出數據之間使用一個空格隔開,第二行輸出排序後的序列，每個輸出數據之間使用一個空格隔開。
輸入樣例：
14
39 80 76 41 13 29 50 78 30 11 100 7 41 86
輸出樣例：
29 50 30 11 7 41 39 13 86 7 29 11 30 41 50 80 78
7 11 13 29 30 39 41 41 50 76 78 80 86 100
public class xier {
public static voidmain(String[] args) {
int[] data;
int[] d={5,3,1};
int n;
Scanner in=newScanner(System.in);
n=in.nextInt();
data=new int[n];
for(inti=0;i<n;i++)data[i]=in.nextInt();
shellsort(data,d);
for(int i=0;i<n;i++)
System.out.print(data[i]+" ");
System.out.println();
}
public static voidshellsort(int[] data,int[] d){
int h,temp,k,j,p;
for(k=0;k<3;k++){
h=d[k];
for(j=h;j<data.length;j++){
if(data[j]<data[j-h]){
temp=data[j];
System.out.print(data[j]+" ");
for(p=j;p>=h&&temp<data[p-h];p=p-h){
data[p]=data[p-h];
}
data[p]=temp;
}
}
}
System.out.println();
}
}