第二十二天
排序树
按照之前的理论，对树执行严格顺序化的插入删除操作，可以使树具有排序约束性。今天来实现一种结构，最简单的排序树。
当新节点加入时，按照小大关系插入节点的左方右方，如果该位置有节点，则递推至该节点继续比较。
删除节点的时候，严格将其他节点重新连接。
不过这里有一个问题，因为二叉树最多只能有两个孩子，如果删除的那个节点的两个子节点都是满节点的话，无法继续连接。那么就要递推到下一个节点，继续执行次操作。
说白了，就是以被删除的节点为中心轴，从左或者从右开始向下搜寻，但是搜寻的路径要尽可能靠近中心轴。
BinarySortTree类：
package com.zht0210.DataStructure;
import java.util.Stack;
import com.zht0210.DataStructure.BinaryTree.BinaryTreeNode;
public class BinarySortTree<T>
{
int maxDepth=100;
class BinaryTreeNode<T>
{
int ID=-1;
BinaryTreeNode<T> firstChild;
BinaryTreeNode<T> rightBrother;
BinaryTreeNode<T> father;
T data;
public void setID(int n)
{
ID=n;
}
}
BinaryTreeNode<T> root;
private int treeSize=0;
public void create(T[] vector,int[] IDs)
{
for(int i=0;i<vector.length;i++)
{
this.insert(IDs[i],vector[i]);
}
}
private BinaryTreeNode<T> find(int id)
{
BinaryTreeNode<T> recursionPoint=root;
int i=0;
while(i++<maxDepth)
{
if(id==recursionPoint.ID)
{
return recursionPoint;
}
if(id>recursionPoint.ID)
{
if(recursionPoint.rightBrother!=null)
recursionPoint=recursionPoint.rightBrother;
else
{
System.out.println("not find id "+id);
return null;
}
}
else
{
if(recursionPoint.firstChild!=null)
recursionPoint=recursionPoint.firstChild;
else
{
System.out.println("not find id "+id);
return null;
}
}
}
return null;
}
public T oldGet(int n)
{
if(n>=treeSize)
{
System.out.println("out of range!");
return null;
}
BinaryTreeNode<T> recursionPoint=root;
Stack<BinaryTreeNode<T>> breakList=new Stack<BinaryTreeNode<T>>();
boolean goif=false;
for(int i=0;i<n;)
{
if(!goif)
{
if(recursionPoint.firstChild!=null)
{
breakList.push(recursionPoint);
recursionPoint=recursionPoint.firstChild;
i++;
continue;
}
}
else
{
goif=false;
}
if(recursionPoint.rightBrother!=null)
{
recursionPoint=recursionPoint.rightBrother;
i++;
}
else
{
recursionPoint=breakList.pop();
goif=true;
}
}
return (T)recursionPoint.data;
}
public T get(int id)
{
BinaryTreeNode<T> temp=find(id);
if(temp!=null)
{
return temp.data;
}
else
{
System.out.println("a null");
return null;
}
}
public int size()
{
return treeSize;
}
public void show(int[] ids)
{
System.out.println("show:");
for(int i=0;i<ids.length;i++)
{
System.out.println(this.get(ids[i]));
}
System.out.println("old show:");
for(int i=0;i<treeSize;i++)
{
System.out.println(this.oldGet(i));
}
}
public void insert(int id,T data)
{
if(root==null)
{
root=new BinaryTreeNode<T>();
root.data=data;
root.ID=id;
treeSize++;
return;
}
BinaryTreeNode<T> recursionPoint=root;
int i=0;
while(i++<maxDepth)
{
if(id>recursionPoint.ID)
{
if(recursionPoint.rightBrother!=null)
recursionPoint=recursionPoint.rightBrother;
else
{
BinaryTreeNode<T> node=new BinaryTreeNode<T>();
treeSize++;
node.data=data;
node.setID(id);
node.father=recursionPoint;
recursionPoint.rightBrother=node;
return;
}
}
else
{
if(recursionPoint.firstChild!=null)
recursionPoint=recursionPoint.firstChild;
else
{
BinaryTreeNode<T> node=new BinaryTreeNode<T>();
treeSize++;
node.data=data;
node.setID(id);
node.father=recursionPoint;
recursionPoint.firstChild=node;
return;
}
}
}
System.out.println("too long");
}
public void delete(int id)
{
BinaryTreeNode<T> pos=find(id);
if(pos!=null)
{
treeSize--;
}
if(pos!=root)
{
if(pos.father.firstChild==pos)
{
if(pos.firstChild==null&&pos.rightBrother==null)
{
pos.father.firstChild=null;
}
else if(pos.firstChild!=null)
{
pos.father.firstChild=pos.firstChild;
pos.firstChild.father=pos.father;
}
else if(pos.rightBrother!=null)
{
pos.father.firstChild=pos.rightBrother;
pos.rightBrother.father=pos.father;
}
else
{
BinaryTreeNode<T> point=pos;
point=point.firstChild;
while(true)
{
if(point.rightBrother==null)
{
break;
}
point=point.rightBrother;
}
delete(point.ID);
point.father=pos.father;
pos.father.firstChild=point;
point.firstChild=pos.firstChild;
pos.firstChild.father=point;
point.rightBrother=pos.rightBrother;
pos.rightBrother.father=point;
}
}
else
{
if(pos.firstChild==null&&pos.rightBrother==null)
{
pos.father.rightBrother=null;
}
else if(pos.firstChild!=null)
{
pos.father.rightBrother=pos.firstChild;
pos.firstChild.father=pos.father;
}
else if(pos.rightBrother!=null)
{
pos.father.rightBrother=pos.rightBrother;
pos.rightBrother.father=pos.father;
}
else
{
BinaryTreeNode<T> point=pos;
point=point.rightBrother;
while(true)
{
if(point.firstChild==null)
{
break;
}
point=point.firstChild;
}
delete(point.ID);
point.father=pos.father;
pos.father.rightBrother=point;
point.firstChild=pos.firstChild;
pos.firstChild.father=point;
point.rightBrother=pos.rightBrother;
pos.rightBrother.father=point;
}
}
}
else
{
root=null;
}
}
}
基本上跟二叉树的代码差不多
test：
private void BSortTest()
{
bstree.insert(50, 50);
bstree.insert(25, 25);
bstree.insert(23, 23);
bstree.insert(70, 70);
bstree.insert(99, 99);
bstree.insert(39, 39);
bstree.insert(42, 42);
int[] sh= {50,25,23,70,99,39,42};
bstree.show(sh);
bstree=null;
bstree=new BinarySortTree<Integer>();
Integer[] vec= {50,25,23,39,42,70,99};
int[] IDs= {50,25,23,39,42,70,99};
bstree.create(vec,IDs);
bstree.show(IDs);
}
代码有问题，在平衡二叉树中已经改进。
平衡二叉树
通过排序二叉树，可以实现按顺序对二叉树进行插入删除操作，但是问题是，我们这样插出来的二叉树很可能是一个歪歪扭扭的二叉树（只有正态分布的数据随机插入，并且头一个根节点靠近均值位置，才有可能插的比较丰满，想一下高中学正态分布的时候出现的一张小球阶梯下落图）。
如果我们使用固定长度数组来存储二叉树的话，就会浪费很多空间，很自然的就会有人考虑二叉树的平衡问题。
首先考虑二叉树能否平衡？我们画一张图，画一张二叉树的图，并把每个叶子节点和根节点都按顺序排列，会发现，二叉树的所有元素都可以按从小到大的顺序排成一维数轴上的点。既然都是一维的点，那么就无所谓先后只分了，我们可以任意安排根节点，中间节点及叶子节点的位置，所以二叉树是可以任意变换的，当然也就可以变换成平衡二叉树。
//插入内部泛型类：
BinaryTree<Integer>.BinaryTreeNode<Integer> bn=btree.new BinaryTreeNode<Integer>();
//插入 end
目前的教程基本都是用左平衡右平衡来实现平衡二叉树，其实就是跷跷板，高低头互换了。另外在平衡二叉树中，只要保证上一次是平衡的，那么下一次加入删除的时候，只需要利用平衡值变化就可以计算新的平衡值了，而不用计算树的深度。
而我一开始没有想到，所以用的深度来计算的，不过好处是未来扩展方便，可以很轻易的处理非平衡树的动态平衡。
package com.zht0210.DataStructure;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.Random;
import java.util.Vector;
import com.zht0210.DataStructure.BinaryTree.BinaryTreeNode;
public class StructureTest
{
Vector<Integer> vec=new Vector<Integer>();
MyQueue<Integer> que=new MyQueue<Integer>();
ArrayDeque<Integer> jque=new ArrayDeque<Integer>();
BinaryTree<Integer> btree=new BinaryTree<Integer>();
BinarySortTree<Integer> bstree=new BinarySortTree<Integer>();
AVL<Integer> avltree=new AVL<Integer>();
public void test()
{
//vectorSafeTest();
//queueTest();
//timeTest();
//treeTest();
//BSortTest();
AVLTest();
}
private void AVLTest()
{
ArrayList<Integer> nums=new ArrayList<Integer>();
Random r=new Random();
int id=0;
id=r.nextInt(100);
System.out.println("id=="+id);
boolean in;
for(int n=0;n<50;n++)
{
in=true;
while(in)
{
in=false;
for(int i=0;i<nums.size();i++)
{
if(id==nums.get(i))
{
id=r.nextInt(100);
in=true;
}
}
}
nums.add(id);
avltree.balanceInsert(id, id);
avltree.treeShow();
}
// avltree.balanceInsert(32, 32);
// avltree.balanceInsert(3, 3);
// avltree.balanceInsert(58, 58);
// avltree.balanceInsert(1, 1);
// avltree.balanceInsert(51, 51);
// avltree.balanceInsert(65, 65);
// avltree.balanceInsert(43, 43);
// avltree.balanceInsert(52, 52);
// avltree.treeShow();
System.out.println("------------------------now test delete------------------");
for(int i=0;i<nums.size();i++)
{
System.out.println("delete "+nums.get(i));
avltree.balanceDelete(nums.get(i));
avltree.treeShow();
}
//avltree.balanceDelete(65);
//avltree.treeShow();
}
private void BSortTest()
{
bstree.insert(50, 50);
bstree.insert(25, 25);
bstree.insert(23, 23);
bstree.insert(70, 70);
bstree.insert(99, 99);
bstree.insert(39, 39);
bstree.insert(42, 42);
bstree.delete(25);
int[] sh= {50,25,23,70,99,39,42};
bstree.show(sh);
bstree=null;
bstree=new BinarySortTree<Integer>();
Integer[] vec= {50,25,23,39,42,70,99};
int[] IDs= {50,25,23,39,42,70,99};
bstree.create(vec,IDs);
bstree.show(IDs);
}
private void timeTest()
{
int size=10000;
long time,time1,time2;
time1=System.nanoTime();
for(int i=0;i<size;i++)
{
que.addFront(i);
}
time2=System.nanoTime();
time=time2-time1;
System.out.println("myque add f "+size+" use:"+time);
time1=System.nanoTime();
for(int i=0;i<size;i++)
{
jque.addFirst(i);
}
time2=System.nanoTime();
time=time2-time1;
System.out.println("javaque add f "+size+" use:"+time);
time1=System.nanoTime();
for(int i=0;i<size;i++)
{
que.get(i);
}
time2=System.nanoTime();
time=time2-time1;
System.out.println("myque get i "+size+" use:"+time);
time1=System.nanoTime();
for(int i=0;i<size;i++)
{
jque.peek();
}
time2=System.nanoTime();
time=time2-time1;
System.out.println("javaque get f "+size+" use:"+time);
}
private void treeTest()
{
Integer[] list= {0,1,2,3,4,5,6,7,8,9};
Integer[] setList= {0,1,2,4,null,null,5,null,null,3,null,null,6,null,7,8,null,null,9,null,null};
//btree.testSet(list);
//btree.testGet();
btree.create(setList);
//System.out.println(btree.get(6));
//btree.testGet();
btree.show();
System.out.println("--------");
}
private void queueTest()
{
//que.addFront(0);
//que.addFront(1);
for(int i=0;i<15;i++)
{
que.addRear(i);
}
que.show();
for(int i=0;i<15;i++)
{
que.addFront(i);
}
for(int i=0;i<30;i++)
{
que.removeFront();
//que.removeRear();
}
que.show();
}
private void vectorSafeTest()
{
SafeTest.st=this;
for(int i=0;i<3;i++)
{
SafeTest st1=new SafeTest();
st1.start();
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(vec.size());
Integer a=new Integer(5555555);
Integer b=new Integer(4444444);
System.out.println(a.hashCode());
System.out.println(b.hashCode());
}
}
我这里的代码都是按照自己的思路来写的，写的很混乱，完全不如网上所说的四种情况来的方便。但是四种情况必须要保证上一次也是平衡树的时候才能使用。
第二十三天/二十四天
排序算法
package com.zht0321.Sort;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Stack;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
public class SortClass
{
int[] input;
int[] output;
int swapCount=0;
int compCount=0;
CompareUnit comp=new CompareUnit();
int count=0;
int[][] splitArray;
public void setInput(int[] in)
{
int temp;
input=new int[in.length];
output=new int[in.length];
for(int i=0;i<in.length;i++)
{
temp=in[i];
input[i]=temp;
}
}
public int[] getOutput()
{
return output;
}
private void swap(int[] array,int i,int j)
{
int temp=0;
temp=array[i];
array[i]=array[j];
array[j]=temp;
}
public void swapSort()
{
reset();
swapCount=0;
compCount=0;
for(int it0=0;it0<input.length;it0++)
{
for(int it1=it0+1;it1<input.length;it1++)
{
if(comp.compare(output[it1], output[it0])==1)
{
swapCount++;
swap(output,it0,it1);
}
compCount++;
}
}
}
public void steadySwapSort()
{
reset();
swapCount=0;
compCount=0;
int max=0;
int maxIndex=0;
for(int it0=0;it0<input.length;it0++)
{
max=output[it0];
maxIndex=it0;
for(int it1=it0+1;it1<input.length;it1++)
{
if(comp.compare(output[it1], max)==1)
{
max=output[it1];
maxIndex=it1;
}
compCount++;
}
swapCount++;
swap(output,it0,maxIndex);
}
}
public void reset()
{
int temp;
for(int i=0;i<input.length;i++)
{
temp=input[i];
output[i]=temp;
}
}
public void bubbleSort()
{
reset();
swapCount=0;
compCount=0;
for(int it0=0;it0<input.length;it0++)
{
for(int it1=0;it1<input.length-it0-1;it1++)
{
if(comp.compare(output[it1], output[it1+1])==-1)
{
swapCount++;
swap(output,it1,it1+1);
}
compCount++;
}
}
}
public void bubblePlusSort()
{
reset();
swapCount=0;
compCount=0;
int end=0;
for(int it0=0;it0<input.length&&!false;it0++)
{
for(int it1=0;it1<input.length-it0-1;it1++)
{
if(comp.compare(output[it1], output[it1+1])==-1)
{
swapCount++;
swap(output,it1,it1+1);
end=it1;
}
compCount++;
}
if(end==0)
{
break;
}
end=0;
}
}
public void insertSort()
{
reset();
swapCount=0;
compCount=0;
ArrayList<Integer> card=new ArrayList<Integer>();
int c=0;
for(int it0=0;it0<input.length;it0++)
{
c=0;
for(int it1=0;it1<card.size();it1++)
{
if(input[it0]>card.get(it1))
{
card.add(it1, input[it0]);
break;
}
else
{
c++;
}
compCount++;
}
if(c==card.size())
{
card.add(input[it0]);
}
swapCount++;
}
for(int i=0;i<card.size();i++)
{
output[i]=card.get(i);
}
}
public void shellSort()
{
reset();
swapCount=0;
compCount=0;
int invat=0;
invat=input.length;
while(invat>1)
{
invat=invat/3+1;
for(int it0=0;it0+invat<output.length;it0++)
{
if(comp.compare(output[it0], output[it0+invat])==-1)
{
int it1=0;
int save=output[it0+invat];
for(it1=it0;it1>0&&comp.compare(save, output[it1])==1;it1-=invat)
{
output[it1+invat]=output[it1];
compCount++;
}
output[it1+invat]=save;
compCount++;
}
}
}
for(int it0=0;it0+1<input.length;it0++)
{
if(comp.compare(output[it0], output[it0+1])==-1)
{
int save=output[it0+1];
for(int it1=0;it0-it1>=0;it1++)
{
compCount++;
if(comp.compare(output[it0+1-it1], save)==1||comp.compare(output[it0+1-it1], save)==0)
{
output[it0+1-it1]=output[it0-it1];
}
else
{
output[it0-it1]=save;
break;
}
if(it0-it1==0)
{
output[it0-it1]=save;
}
}
compCount++;
}
}
}
public void heapSort()
{
reset();
swapCount=0;
compCount=0;
int n=0;
int[] temp=new int[output.length+1];
temp[temp.length-1]=Integer.MIN_VALUE;
for(int i=0;i<output.length;i++)
{
temp[i]=output[i];
}
for(int i=input.length/2;i>0;i--)
{
n=i;
while(n<=input.length/2)
{
if(comp.compare(temp[n-1], temp[n*2-1])==-1)
{
if(comp.compare(temp[n*2-1], temp[n*2])==-1)
{
swap(temp,n-1,n*2);
n=n*2+1;
swapCount++;
}
else
{
swap(temp,n-1,n*2-1);
n=n*2;
swapCount++;
}
compCount++;
}
else if(comp.compare(temp[n-1], temp[n*2])==-1)
{
swap(temp,n-1,n*2);
n=n*2+1;
swapCount++;
}
else
{
compCount++;
break;
}
compCount++;
}
}
int point=0;
for(int i=0;i<input.length;i++)
{
point=temp.length-i-2;
output[i]=temp[0];
//System.out.println("point:"+point+" temp[0]:"+temp[0]+" temp[point]:"+temp[point]);
temp[0]=temp[point];
n=1;
while(true)
{
if(n*2-1>=point)
{
break;
}
//System.out.println("now n:"+n);
if(comp.compare(temp[n-1], temp[n*2-1])==-1)
{
if(comp.compare(temp[n*2-1], temp[n*2])==-1)
{
swap(temp,n-1,n*2);
n=n*2+1;
swapCount++;
}
else
{
swap(temp,n-1,n*2-1);
n=n*2;
swapCount++;
}
compCount++;
}
else if(comp.compare(temp[n-1], temp[n*2])==-1)
{
swap(temp,n-1,n*2);
n=n*2+1;
swapCount++;
}
else
{
compCount++;
break;
}
compCount++;
}
}
}
public void mergingSort()
{
reset();
swapCount=0;
compCount=0;
int nums=0;
int range=1;
int le=0;
int ra=0;
int rel=0;
while(range<=input.length/2)
{
nums=input.length/(range)+input.length%(range);
rel=0;
for(int it0=0;it0<nums;it0=it0+2)
{
le=it0*range;
ra=(it0+1)*range;
if(ra>=output.length)
{
rel=output.length-le;
break;
}
if(ra+range>=output.length)
{
int d=output.length-ra;
int[] tle=new int[range];
System.arraycopy(output, le, tle, 0, range);
int[] tra=new int[d];
System.arraycopy(output, ra, tra, 0, d);
int[] mer=new int[range+d];
int leP=0;
int raP=0;
for(int i=0;i<mer.length;i++)
{
if(leP==tle.length)
{
mer[i]=tra[raP];
raP++;
}
else if(raP==tra.length)
{
mer[i]=tle[leP];
leP++;
}
else if(comp.compare(tle[leP],tra[raP])==-1)
{
compCount++;
mer[i]=tra[raP];
raP++;
}
else
{
compCount++;
mer[i]=tle[leP];
leP++;
}
}
System.arraycopy(mer, 0, output, le, mer.length);
break;
}
int[] tle=new int[range];
System.arraycopy(output, le, tle, 0, range);
int[] tra=new int[range];
System.arraycopy(output, ra, tra, 0, range);
int[] mer=new int[2*range];
int leP=0;
int raP=0;
for(int i=0;i<mer.length;i++)
{
if(leP==tle.length)
{
mer[i]=tra[raP];
raP++;
}
else if(raP==tra.length)
{
mer[i]=tle[leP];
leP++;
}
else if(comp.compare(tle[leP],tra[raP])==-1)
{
compCount++;
mer[i]=tra[raP];
raP++;
}
else
{
compCount++;
mer[i]=tle[leP];
leP++;
}
}
System.arraycopy(mer, 0, output, le, mer.length);
}
range=range*2;
}
if(rel>0)
{
int[] tle=new int[input.length-rel];
System.arraycopy(output, 0, tle, 0, output.length-rel);
int[] tra=new int[rel];
System.arraycopy(output, output.length-rel, tra, 0, rel);
int[] mer=new int[input.length];
int leP=0;
int raP=0;
for(int i=0;i<mer.length;i++)
{
if(leP==tle.length)
{
mer[i]=tra[raP];
raP++;
}
else if(raP==tra.length)
{
mer[i]=tle[leP];
leP++;
}
else if(comp.compare(tle[leP],tra[raP])==-1)
{
compCount++;
mer[i]=tra[raP];
raP++;
}
else
{
compCount++;
mer[i]=tle[leP];
leP++;
}
}
output=mer;
}
}
public void quickSort()
{
reset();
swapCount=0;
compCount=0;
int pLow=0;
int pHigh=input.length-1;
int begin=0;
int end=0;
//Stack<Integer> stack=new Stack<Integer>();
SortStack stack=new SortStack();
stack.push(pLow);
stack.push(pHigh);
int piv=0;
while(stack.size()>0)
{
pHigh=stack.pop();
pLow=stack.pop();
begin=pLow;
end=pHigh;
piv=output[pLow];
while(pLow<pHigh)
{
while(pLow<pHigh&&(comp.compare(piv, output[pHigh])==1||comp.compare(piv, output[pHigh])==0))
{
pHigh--;
compCount++;
}
compCount++;
output[pLow]=output[pHigh];
while(pLow<pHigh&&(comp.compare(output[pLow],piv)==1||comp.compare(output[pLow],piv)==0))
{
pLow++;
compCount++;
}
compCount++;
output[pHigh]=output[pLow];
}
output[pLow]=piv;
if(pLow-begin>1)
{
stack.push(begin);
stack.push(pLow-1);
}
if(end-pHigh>1)
{
stack.push(pHigh+1);
stack.push(end);
}
}
}
public void multiSort()
{
long time,time1,time2;
QuickSortThread qs1=new QuickSortThread();
QuickSortThread qs2=new QuickSortThread();
QuickSortThread qs3=new QuickSortThread();
int invat=input.length/3;
int[] a=new int[invat];
int[] b=new int[invat];
int[] c=new int[invat+input.length%invat];
System.arraycopy(input, 0, a, 0, invat);
System.arraycopy(input, invat, b, 0, invat);
System.arraycopy(input, 2*invat, c, 0, c.length);
splitArray=new int[3][];
qs1.set(a,this);
qs2.set(b,this);
qs3.set(c,this);
qs1.start();
qs2.start();
qs3.start();
synchronized(this)
{
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
time1=System.nanoTime();
synchronized(this)
{
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
a=splitArray[0];
b=splitArray[1];
c=splitArray[2];
int apoint=0;
int bpoint=0;
int cpoint=0;
time2=System.nanoTime();
time=time2-time1;
System.out.println("multi time "+time);
time1=System.nanoTime();
for(int i=0;i<input.length;i++)
{
if(apoint==a.length)
{
if(bpoint==b.length)
{
output[i]=c[cpoint];
cpoint++;
continue;
}
else if(cpoint==c.length)
{
output[i]=b[bpoint];
bpoint++;
continue;
}
else
{
if(b[bpoint]>c[cpoint])
{
output[i]=b[bpoint];
bpoint++;
continue;
}
else
{
output[i]=c[cpoint];
cpoint++;
continue;
}
}
}
if(bpoint==b.length)
{
if(apoint==a.length)
{
output[i]=c[cpoint];
cpoint++;
continue;
}
else if(cpoint==c.length)
{
output[i]=a[apoint];
apoint++;
continue;
}
else
{
if(a[apoint]>c[cpoint])
{
output[i]=a[apoint];
apoint++;
continue;
}
else
{
output[i]=c[cpoint];
cpoint++;
continue;
}
}
}
if(cpoint==c.length)
{
if(apoint==a.length)
{
output[i]=b[bpoint];
bpoint++;
continue;
}
else if(bpoint==b.length)
{
output[i]=a[apoint];
apoint++;
continue;
}
else
{
if(a[apoint]>b[bpoint])
{
output[i]=a[apoint];
apoint++;
continue;
}
else
{
output[i]=b[bpoint];
bpoint++;
continue;
}
}
}
if(a[apoint]>b[bpoint])
{
if(c[cpoint]>a[apoint])
{
output[i]=c[cpoint];
cpoint++;
continue;
}
else
{
output[i]=a[apoint];
apoint++;
continue;
}
}
//a<b
if(c[apoint]>b[bpoint])
{
output[i]=c[cpoint];
cpoint++;
continue;
}
//a<b c<b
output[i]=b[bpoint];
bpoint++;
continue;
}
time2=System.nanoTime();
time=time2-time1;
System.out.println("merging time "+time);
}
public void showCount()
{
System.out.println("swap count:"+swapCount);
System.out.println("compare count:"+compCount);
}
}
测试类
package com.zht0321.Sort;
import java.util.Random;
public class SortTest
{
int size=100000;
int show=1;
int max=size*2;
Random r=new Random();
SortClass sc=new SortClass();
int[] ra=new int[size];
int[] rao=new int[size];
public void test()
{
generate();
sc.setInput(ra);
System.out.println("-------------result quick------------");
long time,time1,time2;
time1=System.nanoTime();
System.out.println("size "+sc.input.length);
sc.quickSort();
rao=sc.getOutput();
time2=System.nanoTime();
time=time2-time1;
System.out.println("single time cost "+time);
System.out.println("-------------result multi------------");
time1=System.nanoTime();
sc.multiSort();
rao=sc.getOutput();
time2=System.nanoTime();
time=time2-time1;
//System.out.println("multi time cost "+time);
}
public void otest()
{
generate();
int[] ras= {5,1,9,3,7,4,8,6,2};
//ra=ras;
show(ra);
sc.setInput(ra);
System.out.println("--------result swap--------------");
sc.swapSort();
rao=sc.getOutput();
show(rao);
sc.showCount();
sc.reset();
System.out.println("--------result steady swap--------------");
sc.steadySwapSort();
rao=sc.getOutput();
show(rao);
sc.showCount();
sc.reset();
System.out.println("-------------result bubble------------");
sc.bubbleSort();
rao=sc.getOutput();
show(rao);
sc.showCount();
sc.reset();
System.out.println("-------------result bubble plus------------");
sc.bubblePlusSort();
rao=sc.getOutput();
show(rao);
sc.showCount();
sc.reset();
System.out.println("-------------result insert------------");
sc.insertSort();
rao=sc.getOutput();
show(rao);
sc.showCount();
sc.reset();
System.out.println("-------------result shell------------");
sc.shellSort();
rao=sc.getOutput();
show(rao);
sc.showCount();
sc.reset();
System.out.println("-------------result heap------------");
sc.heapSort();
rao=sc.getOutput();
show(rao);
sc.showCount();
sc.reset();
System.out.println("-------------result merging------------");
sc.mergingSort();
rao=sc.getOutput();
show(rao);
sc.showCount();
sc.reset();
System.out.println("-------------result quick------------");
sc.quickSort();
rao=sc.getOutput();
show(rao);
sc.showCount();
sc.reset();
}
private void show(int[] s)
{
for(int i=0;i<s.length;i++)
{
if(i%10==0)
System.out.println();
System.out.print(s[i]+" ");
}
System.out.println();
}
private void generate()
{
int temp=0;
for(int i=0;i<size;i++)
{
temp=r.nextInt(max);
ra[i]=temp;
}
}
}
非同步栈
package com.zht0321.Sort;
public class SortStack
{
int[] value=new int[100000];
int point=0;
int size=0;
public int pop()
{
point--;
size--;
return value[point];
}
public void push(int a)
{
value[point]=a;
size++;
point++;
}
public int size()
{
return size;
}
}
快速排序线程
package com.zht0321.Sort;
import java.util.concurrent.atomic.AtomicInteger;
public class QuickSortThread extends Thread
{
SortClass sc=new SortClass();
SortClass master;
public void set(int[] in,SortClass m)
{
master=m;
sc.setInput(in);
}
public void run()
{
synchronized(master)
{
master.count++;
if(master.count==3)
{
master.notifyAll();
}
else
{
try {
master.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
int[] out=new int[sc.input.length];
long time,time1,time2;
time1=System.nanoTime();
sc.quickSort();
out=sc.getOutput();
time2=System.nanoTime();
time=time2-time1;
System.out.println("out size "+out.length);
System.out.println("one thread down "+time);
synchronized(master)
{
master.count--;
master.splitArray[master.count]=out;
if(master.count==0)
{
master.notify();
}
}
}
}
比较器
package com.zht0321.Sort;
public class CompareUnit
{
public int compare(int a,int b)
{
if(a>b)
{
return 1;
}
if(a==b)
{
return 0;
}
return -1;
}
}
实现了基础交换排序，优化交换排序，冒泡排序，优化冒泡排序，插入排序，希尔排序，堆排序，归并排序，快速排序，多线程快速排序。
扫一扫
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
