把目前学习的排序算法记下来，方便以后复习
package Sort;
//冒泡
public class SimpleSort {
public static void main(String[] args) {
int[] a={3,2,5,4,1};
//System.out.println(a.length);
sort(a);
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
private static void sort(int[] a) {
int temp=0;
for(int i=0;i<a.length;i++){
for(int j=0;j<a.length-i-1;j++){
if(a[j]>a[j+1]){
temp=a[j+1];
a[j+1]=a[j];
a[j]=temp;
}
}
}
}
}
package Sort;
//插入
public class InsertSort {
private static int i=0;
private static int temp=0;
public static void main(String[] args) {
int[] a = {7,8,9,4,5,3,2,6};
insertSort(a,a.length);
print(a);
}
private static void print(int[] a) {
for(i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
private static void insertSort(int[] a, int n) {
//插入排序是从第一张牌开始，即假设第一张牌已经有序
for(int p=1;p<n;p++){
//用temp保存当前值
temp=a[p];
//令i等于当前位置，当i>=1（即不是最初的那个位置）且前一张牌大于当前牌值
//循环一遍，i--向前移动一位
for(i=p;i>=1&&a[i-1]>temp;i-=1)
//将前牌值赋给当前牌值
a[i]=a[i-1];
//再把temp值赋给前一个位置值，这里看似还是给i赋值，但是循环一遍结束，i--即已经向前移动一位
//当前i值表示前一位的位置
a[i]=temp;
}
}
}
package Sort;
//希尔
public class ShellSort {
private static int i=0;
private static int temp=0;
private static int D;
public static void main(String[] args) {
int[] a = { 61, 25, 29, 105, 52, 108, 73, 58, 38, 64, 14, 55, 98, 94, 102, 35, 60, 68, 15, 27, 103,
73, 55, 35, 33, 47, 35, 16, 31, 108, 46, 65, 89, 13, 51, 51, 99, 113, 66, 111, 99, 64, 54,
117, 20, 14, 106, 9, 29, 11, 25, 100, 58, 79, 69, 84, 106, 59, 92, 42, 11, 92, };
shellSort(a,a.length);
print(a,a.length);
}
private static void print(int[] a, int n) {
for(i=0;i<n;i++){
System.out.println(a[i]);
}
}
private static void shellSort(int[] a, int n) {
//希尔增列，通常初始化为n/2，循环条件大于0；步长D/2
for(D=n/2;D>0;D/=2){
//将1换成希尔增列D的插入排序
//先拿到D张牌，
for(int p=D;p<n;p++){
//存取当前牌值
temp=a[p];
//与前D张牌比较，步长i-D
for(i=p;i>=D&&a[i-D]>temp;i-=D)
//swap
a[i]=a[i-D];
//将临时值temp赋给前D张牌值
a[i]=temp;
}
}
}
}
package Sort;
//快排
public class QuickSort {
public static void main(String[] args) {
int[] a = { 61, 25, 29, 105, 52, 108, 73, 58, 38, 64, 14, 55, 98, 94, 102, 35, 60, 68, 15, 27, 103,
73, 55, 35, 33, 47, 35, 16, 31, 108, 46, 65, 89, 13, 51, 51, 99, 113, 66, 111, 99, 64, 54,
117, 20, 14, 106, 9, 29, 11, 25, 100, 58, 79, 69, 84, 106, 59, 92, 42, 11, 92, };
quickSort(a,0,a.length-1);
for (int k : a) {
System.out.println(k);
}
}
public static void quickSort(int[] a,int l,int h){
//先定义一个位置
int pos;
if(l<h){
//首先找到第一个数的确切位置
pos=find(a,l,h);
//从第一个数左边一半递归
quickSort(a,l,pos-1);
//第一个数位置右边一半递归
quickSort(a,pos+1,h);
}
}
public static int find(int[] a,int l,int h){
//先取数组的第一个数，开始排序
int val=a[l];
//l和h重合时，循环结束，l++，h--
while(l<h){
//若h和l重合且a[h]元素大于等于第一个元素时候，继续向前遍历
while(h>l&&a[h]>=val){
//继续往前遍历
h--;
}
//若不满足时候，即将a[h]值赋给a[l]
a[l]=a[h];
//若l和h重合且a[l]元素等于第一个元素时，继续向后遍历
while(l<h&&a[l]<=val){
//继续遍历
l++;
}
//不满足时，将a[l]赋给a[h];
a[h]=a[l];
}
//第一次遍历完，将第一个数的值赋给当前a[l]，且返回l的为位置，即为第一个数的位置
//其实l和h已经重合，即此时候l位置即为val值的位置，将val赋给该位置，即第一个数的确切位置，且返回第一个数的位置
a[l]=val;
return l;
}
}
package Sort;
//归并
public class MergeSort {
private static int i;
public static void main(String[] args) {
int[] a = { 61, 25, 29, 105, 52, 108, 73, 58, 38, 64, 14, 55, 98, 94, 102, 35, 60, 68, 15, 27, 103,
73, 55, 35, 33, 47, 35, 16, 31, 108, 46, 65, 89, 13, 51, 51, 99, 113, 66, 111, 99, 64, 54,
117, 20, 14, 106, 9, 29, 11, 25, 100, 58, 79, 69, 84, 106, 59, 92, 42, 11, 92, };
mergeSort(a, a.length);
print(a);
}
private static void mergeSort(int[] a, int length) {
sort(a, 0, a.length - 1);
}
private static void print(int[] a) {
for (i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
private static void sort(int[] a, int left, int right) {
if (left >= right)
return;
int leftEnd = (left + right) / 2;
sort(a, left, leftEnd);
sort(a, leftEnd + 1, right);
merge(a, left, leftEnd, right);
}
private static void merge(int[] a, int left, int leftEnd, int right) {
// 临时数组
int[] temp = new int[a.length];
// 右边第一个索引
int rightFirst = leftEnd + 1;
// 临时数组的索引
int tempIndex = left;
// 保存当前数组的第一个索引
int tem = left;
while (left <= leftEnd && rightFirst <= right) {
if (a[left] <= a[rightFirst]) {
temp[tempIndex++] = a[left++];
} else {
temp[tempIndex++] = a[rightFirst++];
}
}
// 将剩余的元素拷贝到临时数组中,实际上只会执行两个while的其中一个
while (rightFirst <= right) {
temp[tempIndex++] = a[rightFirst++];
}
while (left <= leftEnd) {
temp[tempIndex++] = a[left++];
}
// 最后将临时数组的元素拷贝到原数组中left到right中
while (tem <= right) {
a[tem] = temp[tem++];
}
}
}
package Sort;
//堆排
public class HeapSort {
public static void main(String[] args) {
int[] arry={5, 3, 6, 2, 1, 9, 4, 8, 7};
heapSort(arry);
print(arry);
}
private static void print(int[] arry) {
for(int i=0;i<arry.length;i++){
System.out.print(arry[i]+"\t");
}
System.out.println();
}
//排序
public static void heapSort(int[] arry){
for(int i=0;i<arry.length;i++){
//找到最后一个索引
int lastindex=arry.length-1-i;
//1.重建最大堆
buildHeap(arry,lastindex);
//2.堆顶与最后一位替换
swap(arry,0,arry.length-1-i);
print(arry);
}
}
//左子节点：2*i+1，右子节点：2*i-1
private static void buildHeap(int[] arry,int lastindex) {
for(int i=(lastindex-1)/2;i>=0;i--){
//k保存当前判断节点
int k=i;
//判断当前节点是否存在子节点
while(2*k+1<=lastindex){
//定义当前节点的左子节点
int biggerindex=2*k+1;
//判断是否存在右子节点
if(biggerindex<lastindex){
//若当前节点的左子节点小于右子节点时，使最大索引改为右子节点
if(arry[biggerindex]<arry[biggerindex+1]){
biggerindex++;
}
}
//如果当前节点的根节点小于最大子节点，则将最大值赋当前根节点
if(arry[k]<arry[biggerindex]){
swap(arry,k,biggerindex);
//因为swap后，需要再将大值节点值赋给当前节点，重新进入while循环判断当前节点是否含有子节点，并比较大小
k=biggerindex;
}else{
break;
}
}
}
}
//交换
private static void swap(int[] arry,int i,int j) {
if(i==j){
return;
}
arry[i]=arry[i]+arry[j];
arry[j]=arry[i]-arry[j];
arry[i]=arry[i]-arry[j];
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
