利用JAVA实现数据结构中常用的插入排序和快速排序算法
利用JAVA实现数据结构中常用的插入排序和快速排序算法在网上看的,挺全的,收了先。。
第十章排序
源程序:
Data.java
package Sort;
class Data {
Comparable key;
Object value;
public Data() {
}
public Data(Data data){
this.key=data.key;
this.value=data.value;
}
public Data(Comparable key,Object value){
this.key=key;
this.value=value;
}
public String toString(){
return "key="+key+";"+"value="+value+";"+"\n";
}
}
Insertion.java
package Sort;
public class InsertionSort {
public InsertionSort() {
}
//直接插入排序,从下标1开始
public static void straightInsertionSort(Data[] data) {
int i, j;
for (i = 2; i if (data[i]https://www.360docs.net/doc/6c1164222.html,pareTo(data[i - 1].key) < 0) { data[0] = data[i];//复制为监视哨 for (j = i - 1; data[0]https://www.360docs.net/doc/6c1164222.html,pareTo(data[j].key) < 0; --j) { data[j + 1] = data[j];//记录右移 } data[j + 1] = data[0];//插入 } } //折半插入排序,从下标1开始 public static void BinaryInsertionSort(Data[] data){ int i,j,low,high,mid; for(i=2;i if (data[i]https://www.360docs.net/doc/6c1164222.html,pareTo(data[i - 1].key) < 0) { data[0]=data[i]; //找插入位置 low=1;high=i-1; while(low<=high){ mid =(low+high)/2; if(data[0]https://www.360docs.net/doc/6c1164222.html,pareTo(data[mid].key)<0) high=mid-1; else low=mid+1; } //移动插入位置以后的元素 for(j=i-1;j>=high+1;j--){ data[j+1]=data[j]; } data[high+1]=data[0];//插入 } } } //表插入排序 public static void ListInsertionSort(Data[] data){ int i,j,k; //inner class:Table class Table{ Comparable key; int next; } Table[] table=new Table[data.length]; for(i=1;i table[i]=new Table(); table[i].key=data[i].key; } table[0]=new Table(); table[0].key=new Integer(Integer.MAX_V ALUE); table[0].next=1; table[1].next=0; for(i=2;i for(j=0,k=table[0].next;table[k]https://www.360docs.net/doc/6c1164222.html,pareTo(table[i].key)<=0;j=k,k=table[k].next); table[j].next=i; table[i].next=k; } Data[] newData=new Data[data.length]; int position=table[0].next; for(i=1;i newData[i]=data[position]; position=table[position].next; for(i=1;i data[i]=newData[i]; } } } QuickSort.java package Sort; import Queue.*; public class QuickSort { public QuickSort() { } //起泡排序 public static void BubbleSort(Data[] data) { int i, j, lastChangeIndex; Data temp; i = data.length - 1; while (i > 1) { lastChangeIndex = 1; for (j = 1; j < i; j++) { if (data[j + 1]https://www.360docs.net/doc/6c1164222.html,pareTo(data[j].key) < 0) { temp = data[j + 1]; data[j + 1] = data[j]; data[j] = temp; lastChangeIndex = j; } } i = lastChangeIndex; } } //快速排序 public static void QuickSort(Data[] data) { QSort(data, 1, data.length - 1); } public static void OptimizeQuickSort(Data[] data){ OQSort(data,1,data.length-1); } private static void QSort(Data[] data, int s, int t) { int pivotLoc; if (s < t) { pivotLoc = Partition(data, s, t); //对data[1...data.length-1]进行一次划分QSort(data, s, pivotLoc - 1); //对低子序列进行递归排序 QSort(data, pivotLoc + 1, t); //对高子序列进行递归排序 } private static void OQSort(Data[] data,int s,int t){ int pivotLoc; if(s pivotLoc=RandomPartition(data,s,t); QSort(data, s, pivotLoc - 1); //对低子序列进行递归排序 QSort(data, pivotLoc + 1, t); //对高子序列进行递归排序 } } private static int RandomPartition(Data[] data,int low,int high){ //i是low int i=(int)Math.random()*(high-low)+low; Data temp=data[low]; data[low]=data[i]; data[i]=temp; return Partition(data,low,high); } private static int Partition(Data[] data, int low, int high) { Comparable pivotKey; data[0] = data[low]; pivotKey = data[low].key; //枢轴 while (low < high) { while (low < high && data[high]https://www.360docs.net/doc/6c1164222.html,pareTo(pivotKey) >= 0) { high--; } data[low] = data[high]; while (low < high && data[low]https://www.360docs.net/doc/6c1164222.html,pareTo(pivotKey) <= 0) { low++; } data[high] = data[low]; } data[low] = data[0]; return low; } //堆排序 public static void HeapSort(Data[] data) { //先对顺序表进行堆排序,建立大顶堆 int i; Data temp; for (i = (data.length-1)/2; i > 0; i--) { HeapAdjust(data, i, data.length-1); } //建立大顶堆 for (i = (data.length - 1); i >1; i--) { temp = data[1]; data[1] = data[i]; data[i] = temp; HeapAdjust(data, 1, i - 1); } private static void HeapAdjust(Data[] data, int start, int end) { int j; Data temp; temp = data[start]; for (j = 2 * start; j <=end; j *=2) { if (j < end && data[j]https://www.360docs.net/doc/6c1164222.html,pareTo(data[j+1].key) < 0) { j++; } if (https://www.360docs.net/doc/6c1164222.html,pareTo(data[j].key) >= 0) { break; } data[start] = data[j]; start = j; } data[start] = temp; } //简单选择排序 public static void SimpleSelectSort(Data[] data) { int i, j; Data temp; for (i = 1; i < data.length; i++) { j = MinKey(data, i); if (j != i) { temp = data[i]; data[i] = data[j]; data[j] = temp; } } } private static int MinKey(Data[] data, int start) { int i, j = start; Comparable temp; temp = data[start].key; if (data.length - start == 0) { return start; } for (i = start + 1; i < data.length; i++) { if (https://www.360docs.net/doc/6c1164222.html,pareTo(data[i].key) > 0) { temp = data[i].key; j = i; } } return j; } //归并排序 private static Data[] originalnewData2; originalnewData2 = new Data[data.length]; newData2 = new Data[data.length]; for (int i = 1; i < data.length; i++) { originalnewData2[i]=new Data(); newData2[i] = new Data(); } MSort(data, data, 1, data.length - 1); } private static void MSort(Data[] originalData,Data[] data, int start, int end) { if (start == end) { data[start] = originalData[start]; } else { int mid = (start + end) / 2; MSort(originalData, newData2, start, mid); MSort(originalData, newData2, mid + 1, end); //怎样才能像值传递一样使用引用传递,即不改变它的值 for(int k=start;k<=end;k++) originalnewData2[k]=new Data(newData2[k]); merge(originalnewData2, data, start, mid, end);//这里的data好像不再是一开始传入的data,而是递归时的newData2 } } private static void merge(Data[] newData, Data[] data, int start, int mid, int end) { int i, j; int k=start; for (i = start, j = mid + 1; start <= mid && j <= end; i++) { if (newData[start]https://www.360docs.net/doc/6c1164222.html,pareTo(newData[j].key) <= 0) { data[i] = newData[start++]; } else { data[i] = newData[j++]; } } if (start <= mid) { for (int tempI = start; tempI <= mid; tempI++) { data[i++] = newData[tempI]; } } if (j <= end) { for (int tempJ = j; tempJ <= end; tempJ++) { data[i++] = newData[tempJ]; } } } //基数排序 QueueInterface[] queues=new LinkQueue[10]; for(int i=0;i<10;i++){ queues[i]=new LinkQueue(); } for(d=1;d<=digits;factor*=10,d++){ //distribution for(j=1;j queues[(((Integer)data[j].key).intValue()/factor)%10].put(new Data(data[j])); } //collection for(j=0,k=1;j<10;j++){ while(!queues[j].isEmpty()){ data[k++]=(Data)queues[j].removeHead(); } } } } } 测试类: package Sort; public class Test { public Test() { } //产生测试数据 public static Data[] getData(int size){ Data[] data=new Data[size+1]; int number; for(int i=0;i number=(int) (Math.random() * size*10); data[i] = new Data(new Integer(number),new Integer(number)); } return data; } //复制测试数据 public static Data[] duplicationData(Data[] data){ Data[] duplication=new Data[data.length]; for(int i=1;i duplication[i]=new Data(data[i]); } return duplication; } public static void printData(Data[] data){ for(int i=1;i System.out.print(data[i].toString()); } public static void main(String[] args) { long startTime,stopTime,sortingTime; Data[] data=getData(6000); Data[] data1,data2,data3,data4,data5,data6,data7,data8,data9,data10; data1=duplicationData(data); data2=duplicationData(data); data3=duplicationData(data); data4=duplicationData(data); data5=duplicationData(data); data6=duplicationData(data); data7=duplicationData(data); data8=duplicationData(data); data9=duplicationData(data); data10=duplicationData(data); startTime= System.currentTimeMillis(); Sort.InsertionSort.straightInsertionSort(data1); stopTime= System.currentTimeMillis(); sortingTime=stopTime-startTime; System.out.println("Straight Insertion Sort time is "+ sortingTime); //System.out.println("Straight Insertion Sort Answer"); //printData(data1); startTime= System.currentTimeMillis(); Sort.InsertionSort.BinaryInsertionSort(data2); stopTime= System.currentTimeMillis(); sortingTime=stopTime-startTime; System.out.println("Binary Insertion Sort time is "+ sortingTime); //System.out.println("Binary Insertion Sort Answer"); //printData(data2); startTime= System.currentTimeMillis(); Sort.InsertionSort.ListInsertionSort(data3); stopTime= System.currentTimeMillis(); sortingTime=stopTime-startTime; System.out.println("List Insertion Sort time is "+ sortingTime); //System.out.println("List Insertion Sort Answer"); //printData(data3); startTime= System.currentTimeMillis(); Sort.QuickSort.BubbleSort(data4); stopTime= System.currentTimeMillis(); sortingTime=stopTime-startTime; System.out.println("Bubble Sort time is "+ sortingTime); //System.out.println("Bubble Sort Answer"); //printData(data4); startTime= System.currentTimeMillis(); sortingTime=stopTime-startTime; System.out.println("Quick Sort time is "+ sortingTime); //System.out.println("Quick Sort Answer"); //printData(data5); startTime= System.currentTimeMillis(); Sort.QuickSort.SimpleSelectSort(data6); stopTime= System.currentTimeMillis(); sortingTime=stopTime-startTime; System.out.println("Select Sort time is "+ sortingTime); //System.out.println("Select Sort Answer"); //printData(data6); startTime= System.currentTimeMillis(); Sort.QuickSort.MergingSort(data7); stopTime= System.currentTimeMillis(); sortingTime=stopTime-startTime; System.out.println("Merging Sort time is "+ sortingTime); //System.out.println("Merging Sort Answer"); //printData(data7); startTime= System.currentTimeMillis(); Sort.QuickSort.RadixSort(data8,5); stopTime= System.currentTimeMillis(); sortingTime=stopTime-startTime; System.out.println("Radix Sort time is "+ sortingTime); //System.out.println("Radix Sort Answer"); //printData(data8); startTime= System.currentTimeMillis(); Sort.QuickSort.HeapSort(data); stopTime= System.currentTimeMillis(); sortingTime=stopTime-startTime; //System.out.println("Heap Sort time is "+ sortingTime); //System.out.println("Radix Sort Answer"); //printData(data9); startTime= System.currentTimeMillis(); Sort.QuickSort.OptimizeQuickSort(data10); stopTime= System.currentTimeMillis(); sortingTime=stopTime-startTime; System.out.println("Optimize Quick Sort time is "+ sortingTime); //System.out.println("Optimize Quick Sort Answer"); //printData(data10); } } 测试结果: 各种排序的测试数据表: 关于快排: 快速排序的运行时间与划分是否对称有关,最糟的情况是每次划分时一边是一个元素,一边是n-1个,这种情况的时间复杂度是 在最好的情况是,每次划分的枢轴都是中值,此时的时间复杂度是,在一些书上提到快速排序在平均情况下的复杂度也是,所以可以提出一个处理恶化的方法,在排序算法的每一步,可以随机选取一个元素关键字作为枢轴,这样总体来说平均划分是对称的。 可以把取枢轴的算法改一下: int RandomizedPartition(DataType[] a , int p , int r){ int i= Random(p , r); Swap(a[i] ,a[p]); return Partition(a,p,r); } 可以看出,优化后的快排明显的提高了排序的速度,但是同时也可以看出,当元素很多时,交换的次数也增多了,使得优化后的排序的优势不很明显了,这是因为被排的数据是随机的。 下面显示的是这两种快排对有序的处理时间(数据>7000,内存溢出): 由此可知,优化快排能缓解恶化。 4.快速排序 详细设计 #include 数据结构各种排序算法总结 2009-08-19 11:09 计算机排序与人进行排序的不同:计算机程序不能象人一样通览所有的数据,只能根据计算机的"比较"原理,在同一时间内对两个队员进行比较,这是算法的一种"短视"。 1. 冒泡排序 BubbleSort 最简单的一个 public void bubbleSort() { int out, in; for(out=nElems-1; out>0; out--) // outer loop (backward) for(in=0; in swap(out, min); // swap them } // end for(out) } // end selectionSort() 效率:O(N2) 3. 插入排序 insertSort 在插入排序中,一组数据在某个时刻实局部有序的,为在冒泡和选择排序中实完全有序的。 public void insertionSort() { int in, out; for(out=1; out Quick Sort 程序已就绪,可直接编译运行 #include InfoType info; //其他记录项 }RedType; //记录类型 typedef struct { RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元 int length; //顺序表长度 }SqList; //顺序表类型 intPartition(SqList&L,intlow,int high) {//交换顺序表L中子表L.r[low..high]的记录,使枢轴记录到位,并返回其所在位置 //此时在它之前(后)的记录均不大(小)于它。 KeyTypepivotkey; L.r[0]=L.r[low]; //用子表的第一个记录作枢轴记录 pivotkey=L.r[low].key; //枢轴记录关键字 while(low 数据结构-各类排序算法总结 原文转自: https://www.360docs.net/doc/6c1164222.html,/zjf280441589/article/details/38387103各类排序算法总结 一. 排序的基本概念 排序(Sorting)是计算机程序设计中的一种重要操作,其功能是对一个数据元素集合或序列重新排列成一个按数据元素 某个项值有序的序列。 有n 个记录的序列{R1,R2,…,Rn},其相应关键字的序列是{K1,K2,…,Kn},相应的下标序列为1,2,…,n。通过排序,要求找出当前下标序列1,2,…,n 的一种排列p1,p2,…,pn,使得相应关键字满足如下的非递减(或非递增)关系,即:Kp1≤Kp2≤…≤Kpn,这样就得到一个按关键字有序的记录序列{Rp1,Rp2,…,Rpn}。 作为排序依据的数据项称为“排序码”,也即数据元素的关键码。若关键码是主关键码,则对于任意待排序序列,经排序后得到的结果是唯一的;若关键码是次关键码,排序结果可 能不唯一。实现排序的基本操作有两个: (1)“比较”序列中两个关键字的大小; (2)“移动”记录。 若对任意的数据元素序列,使用某个排序方法,对它按关键码进行排序:若相同关键码元素间的位置关系,排序前与排序后保持一致,称此排序方法是稳定的;而不能保持一致的排序方法则称为不稳定的。 二.插入类排序 1.直接插入排序直接插入排序是最简单的插入类排序。仅有一个记录的表总是有序的,因此,对n 个记录的表,可从第二个记录开始直到第n 个记录,逐个向有序表中进行插入操作,从而得到n个记录按关键码有序的表。它是利用顺序查找实现“在R[1..i-1]中查找R[i]的插入位置”的插入排序。 java程序员必学的十种程序算法 算法1:快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见。事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法(Divide and conquer)策略来把一个串行(list)分为两个子串行(sub-lists)。 算法步骤: 1 从数列中挑出一个元素,称为“基准”(pivot), 2 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。 3 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。 递归的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递归下去,但是这个算法总会退出,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。 算法2:堆排序算法 堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。 堆排序的平均时间复杂度为Ο(nlogn) 。 算法步骤: 创建一个堆H[0..n-1] 把堆首(最大值)和堆尾互换 3. 把堆的尺寸缩小1,并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置 4. 重复步骤2,直到堆的尺寸为1 算法3:归并排序 归并排序(Merge sort,台湾译作:合并排序)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。 算法步骤: 1.直接插入排序 //InsertSort.cpp //This function is to sort SqList # include 一、插入排序(Insertion Sort) 1. 基本思想: 每次将一个待排序的数据元素,插入到前面已经排好序的数列中的适当位置,使数列依然有序;直到待排序数据元素全部插入完为止。 2. 排序过程: 【示例】: [初始关键字] [49] 38 65 97 76 13 27 49 J=2(38) [38 49] 65 97 76 13 27 49 J=3(65) [38 49 65] 97 76 13 27 49 J=4(97) [38 49 65 97] 76 13 27 49 J=5(76) [38 49 65 76 97] 13 27 49 J=6(13) [13 38 49 65 76 97] 27 49 J=7(27) [13 27 38 49 65 76 97] 49 J=8(49) [13 27 38 49 49 65 76 97] 1 2Procedure InsertSort(Var R : FileType); 3//对R[1..N]按递增序进行插入排序, R[0]是监视哨// 4 Begin 5 for I := 2 To N Do //依次插入R[2],...,R[n]// 6 begin 7 R[0] := R; J := I - 1; 8 While R[0] < R[J] Do //查找R的插入位置// 9 begin 10 R[J+1] := R[J]; //将大于R的元素后移// 11 J := J - 1 12 end 13 R[J + 1] := R[0] ; //插入R // 14 end 15 End; //InsertSort // 复制代码 冒泡排序法 1.public class SortArray_01 { 2. public static void main(String args[]) { 3. int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55 }; // 创建一个初始化的一维数组array 4. System.out.println("未排序的数组:"); 5. for (int i = 0; i < array.length; i++) { // 遍历array数组中的元素 6. System.out.print(" " + array[i]); // 输出数组元素 7. if ((i + 1) % 5 == 0) // 每5个元素一行 8. System.out.println(); 9. } 10. int mid; // 定义一个中间变量, 起到临时存储数据的作用 11. for (int i = 0; i < array.length; i++) { // 执行冒 泡排序法 12. for (int j = i; j < array.length; j++) { 13. if (array[j] < array[i]) { 14. mid = array[i]; 15. array[i] = array[j]; 16. array[j] = mid; 17. } 18. } 19. } 20. System.out.println("\n使用冒泡法排序后的数组:"); 21. for (int i = 0; i < array.length; i++) { // 遍历排好序的array数组中的元素 22. System.out.print(" " + array[i]); // 输出数组元素 23. if ((i + 1) % 5 == 0) 24. System.out.println(); // 每5 个元素一行 25. } 26. } 27.} 数组递增排序 实验课题: 【用C描述课本的同学】有以下结构体构成的数组: struct StudentInfo { char ID[10]; char * name; float score; }StuInfo[12]= { {"0800301105", "JACK", 95}, {"0800201505", "LUN", 85}, {"0400820115", "MARY", 75.5}, {"0400850122", "KATE", 78.9}, {"0500201011", "LILI", 88}, {"0800401105", "JACK", 96}, {"0600830105", "JAN", 98.4}, {"0952520012", "SAM", 75}, {"9721000045", "OSCAR", 64}, {"0700301105", "JACK", 97}, {"0458003312", "ZOE", 68.9}, {"0400830211", "BOBI", 87.6} }; 1 使用直接插入的排序方法按照学号的顺序对以上数组进行排序(递增); 2 分别用归并排序和快速排序按照姓名的顺序对以上数组进行排序(递增),有3人的名字是"JACK",注意观察排序是否稳定。 程序代码: 第一种: #include JAVA中在运用数组进行排序功能时,一般有四种方法:快速排序法、冒泡法、选择排序法、插入排序法。 快速排序法主要是运用了Arrays中的一个方法Arrays.sort()实现。 冒泡法是运用遍历数组进行比较,通过不断的比较将最小值或者最大值一个一个的遍历出来。 选择排序法是将数组的第一个数据作为最大或者最小的值,然后通过比较循环,输出有序的数组。 插入排序是选择一个数组中的数据,通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。 <1>利用Arrays带有的排序方法快速排序 import java.util.Arrays; publicclass Test2{ publicstaticvoid main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } } <2>冒泡排序算法 publicstaticint[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;i 算法名称:选择排序 算法定义:在要排序的一组数中,选出最小的一个数与第一个位置的数交换;然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止。算法类型:不稳定排序 算法时间复杂度:O(n2)--[n的平方] 最少移动次数:0 最多移动次数:3(n-1) 算法适用场景:这个算法时间复杂度偏高,一般不选择使用。 算法代码: void select_sort(int *x, int n) { int i, j, min, t; for (i=0; i 算法定义:在要排序的一组数中,假设前面(n-1) [n>=2] 个数已经是排好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序的。如此反复循环,直到全部排好顺序。 算法类型:稳定排序 算法时间复杂度:O(n2)--[n的平方] 算法适用场景:这个算法时间复杂度偏高,一般不选择使用。 算法代码: void insert_sort(int *x, int n) { int i, j, t; for (i=1; i Java程序员必知的8大排序本文主要详解了Java语言的8大排序的基本思想以及实例解读,详细请看下文8种排序之间的关系: 1,直接插入排序 (1)基本思想:在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排 好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数 也是排好顺序的。如此反复循环,直到全部排好顺序。 (2)实例C语言版数据结构 快速排序 -
数据结构 各种排序算法
C语言数据结构 快速排序 源码
数据结构-各类排序算法总结
java程序员必知的十种程序算法
各种排序算法,数据结构中的排序算法
大数据结构排序超级总结材料
JAVA数组的排序方法实例
数据结构C实现排序:直接插入、归并和快速排序(递增)学号
JAVA中运用数组的四种排序方法
数据结构经典七种排序方法
java中8大排序方法