各种算法总结Word文档下载推荐.docx
- 文档编号:22276577
- 上传时间:2023-02-03
- 格式:DOCX
- 页数:41
- 大小:30.63KB
各种算法总结Word文档下载推荐.docx
《各种算法总结Word文档下载推荐.docx》由会员分享,可在线阅读,更多相关《各种算法总结Word文档下载推荐.docx(41页珍藏版)》请在冰豆网上搜索。
i--;
//查找
}
L[i+1]=L[0];
//将元素插入
i=j-1;
//还原有序区指针
2.希尔排序
又称增量缩小排序。
先将序列按增量划分为元素个数相同的若干组,使用直接插入排序法进行排序,然后不断缩小增量直至为1,最后使用直接插入排序完成排序。
增量的选择以及排序最终以1为增量进行排序结束。
shellSort(Node
d)
While(d>
=1)//直到增量缩小为1
Shell(L,d);
d=d/2;
//缩小增量
Shell(Node
For(i=d+1;
i++)
if(L[i]<
L[i-d])
L[0]=L[i];
j=i-d;
While(j>
0&
&
L[j]>
L[0])
L[j+d]=L[j];
j=j-d;
L[j+d]=L[0];
交换排序
1.冒泡排序
将序列划分为无序和有序区,不断通过交换较大元素至无序区尾完成排序。
设计交换判断条件,提前结束以排好序的序列循环。
BubbleSort(Node
L[])
i
j;
Bool
ischanged;
//设计跳出条件
For(j=n;
j<
0;
j--)
ischanged
=false;
For(i=0;
j;
If(L[i]>
L[i+1])//如果发现较重元素就向后移动
temp=L[i];
L[i]=L[i+1];
L[i+1]=temp;
Ischanged
=true;
If(!
ischanged)//若没有移动则说明序列已经有序,直接跳出
Break;
2.快速排序
不断寻找一个序列的中点,然后对中点左右的序列递归的进行排序,直至全部序列排序完成,使用了分治的思想。
递归、分治
选择排序
1.直接选择排序
将序列划分为无序和有序区,寻找无序区中的最小值和无序区的首元素交换,有序区扩大一个,循环最终完成全部排序。
SelectSort(Node
i,j,k;
//分别为有序区,无序区,无序区最小元素指针
k=i;
For(j=i+1;
j++)
If(L[j]<
L[k])
k=j;
If(k!
=i)//若发现最小元素,则移动到有序区
temp=L[k];
L[k]=L[i];
L[i]=L[temp];
2.堆排序
利用大根堆或小根堆思想,首先建立堆,然后将堆首与堆尾交换,堆尾之后为有序区。
建堆、交换、调整堆
HeapSort(Node
BuildingHeap(L);
//建堆(大根堆)
For(int
i=n;
i>
i--)//交换
L[i]=L[0];
L[0]=temp;
Heapify(L,0,i);
//调整堆
BuildingHeap(Node
{
For(i=length/2
-1;
i--)
Heapify(L,i,length);
归并排序
将原序列划分为有序的两个序列,然后利用归并算法进行合并,合并之后即为有序序列。
归并、分治
MergeSort(Node
m,int
n)
k;
If(m<
K=(m+n)/2;
MergeSort(L,m,k);
MergeSort(L,k+1,n);
Merge(L,m,k,n);
基数排序
将数字按位数划分出n个关键字,每次针对一个关键字进行排序,然后针对排序后的序列进行下一个关键字的排序,循环至所有关键字都使用过则排序完成。
对关键字的选取,元素分配收集。
RadixSort(Node
L[],length,maxradix)
m,n,k,lsp;
k=1;
m=1;
temp[10][length-1];
Empty(temp);
//清空临时空间
While(k<
maxradix)
//遍历所有关键字
i=0;
i++)
//分配过程
If(L[i]<
m)
Temp[0][n]=L[i];
Else
Lsp=(L[i]/m)%10;
//确定关键字
Temp[lsp][n]=L[i];
n++;
CollectElement(L,Temp);
//收集
n=0;
m=m*10;
k++;
Java方法
用Java语言实现的各种排序,包括插入排序、冒泡排序、选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。
插入排序:
packageorg.rut.util.algorithm.support;
importorg.rut.util.algorithm.SortUtil;
/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassInsertSortimplementsSortUtil.Sort{
/*(non-Javadoc)
*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
publicvoidsort(int[]data){
inttemp;
for(inti=1;
data.length;
i++){
for(intj=i;
(j>
0)&
(data[j]<
data[j-1]);
j--){
SortUtil.swap(data,j,j-1);
}
}
冒泡排序:
publicclassBubbleSortimplementsSortUtil.Sort{
for(inti=0;
for(intj=data.length-1;
j>
i;
if(data[j]<
data[j-1]){
}选择排序:
publicclassSelectionSortimplementsSortUtil.Sort{
/*
*(non-Javadoc)
*
for(inti=0;
i<
data.length;
i++){
intlowIndex=i;
for(intj=data.length-1;
j>
i;
j--){
if(data[j]<
data[lowIndex]){
lowIndex=j;
SortUtil.swap(data,i,lowIndex);
Shell排序:
publicclassShellSortimplementsSortUtil.Sort{
for(inti=data.length/2;
2;
i/=2){
for(intj=0;
j++){
insertSort(data,j,i);
insertSort(data,0,1);
/**
*@paramdata
*@paramj
*@parami
privatevoidinsertSort(int[]data,intstart,intinc){
for(inti=start+inc;
i+=inc){
=inc)&
data[j-inc]);
j-=inc){
SortUtil.swap(data,j,j-inc);
快速排序:
publicclassQuickSortimplementsSortUtil.Sort{
quickSort(data,0,data.length-1);
privatevoidquickSort(int[]data,inti,intj){
intpivotIndex=(i+j)/2;
//swap
SortUtil.swap(data,pivotIndex,j);
intk=partition(data,i-1,j,data[j]);
SortUtil.swap(data,k,j);
if((k-i)>
1)quickSort(data,i,k-1);
if((j-k)>
1)quickSort(data,k+1,j);
*@return
privateintpartition(int[]data,intl,intr,intpivot){
do{
while(data[++l]<
pivot);
while((r!
=0)&
data[--r]>
SortUtil.swap(data,l,r);
while(l<
r);
returnl;
改进后的快速排序:
publicclassImprovedQuickSortimplementsSortUtil.Sort{
privatestaticintMAX_STACK_SIZE=4096;
privatestaticintTHRESHOLD=10;
int[]stack=newint[MAX_STACK_SIZE];
inttop=-1;
intpivot;
intpivotIndex,l,r;
stack[++top]=0;
stack[++top]=data.length-1;
while(top>
0){
intj=stack[top--];
inti=stack[top--];
pivotIndex=(i+j)/2;
pivot=data[pivotIndex];
//partition
l=i-1;
r=j;
(data[--r]>
pivot));
SortUtil.swap(data,l,j);
if((l-i)>
THRESHOLD){
stack[++top]=i;
stack[++top]=l-1;
if((j-l)>
stack[++top]=l+1;
stack[++top]=j;
//newInsertSort().sort(data);
insertSort(data);
privatevoidinsertSort(int[]data){
归并排序:
publicclassMergeSortimplementsSortUtil.Sort{
int[]temp=newint[data.length];
mergeSort(data,temp,0,data.length-1);
privatevoidmergeSort(int[]data,int[]temp,intl,intr){
intmid=(l+r)/2;
if(l==r)return;
mergeSort(data,temp,l,mid);
mergeSort(data,temp,mid+1,r);
for(inti=l;
=r;
temp[i]=data[i];
inti1=l;
inti2=mid+1;
for(intcur=l;
cur<
cur++){
if(i1==mid+1)
data[cur]=temp[i2++];
elseif(i2>
r)
data[cur]=temp[i1++];
elseif(temp[i1]<
temp[i2])
else
改进后的归并排序:
publicclassImprovedMergeSortimplementsSortUtil.Sort{
privatestaticfinalintTHRESHOLD=10;
privatevoidmergeSort(int[]data,int[]temp,intl,intr){
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 各种 算法 总结