package Java_Interview_Book;
public class Order {
//选择排序,选出最小的与第一个位置交换。。。。。。
public static void selectSort(int[] a) {
int temp;//临时变量
int flag;//标记位置
int length = a.length;//数组长度
for(int i=0;i<length;i++) {
temp = a[i];
flag = i;
for(int j=i+1;j<length;j++) {
if(a[j] < temp) {
temp =a[j];//存储当前最小位置值
flag = j;//标记当前最小位置
}
}
if (flag != i) {//将第i小位置进行数值交换
a[flag] = a[i];
a[i] = temp;
}
}
}
//插入排序,每次加入的数和当前值比较,如果小和当前位置交换
public static void insertSort(int [] a) {
for (int i = 1; i < a.length; i++) {
int temp = a[i];
int j =i;
if(a[j-1] > temp) {
while(j >= 1 && a[j-1] > temp) {
a[j]=a[j-1];
j--;
}
}
a[j] = temp;
}
}
//(单向)冒泡排序,相邻两两比较,假设是小到大输出
public static void bubbleSort(int [] a ) {
int temp;
for (int i = 0; i < a.length; i++) {
for (int j = i+1; j < a.length; j++) {
if(a[i]>a[j]) {
temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
}
//两路归并算法,两个排好序的子序列合并为一个子序列
public static void merge(int []a,int left,int mid,int right){
int []tmp=new int[a.length];//辅助数组
int p1=left,p2=mid+1,k=left;//p1、p2是检测指针,k是存放指针
while(p1<=mid && p2<=right){
if(a[p1]<=a[p2])
tmp[k++]=a[p1++];
else
tmp[k++]=a[p2++];
}
while(p1<=mid) tmp[k++]=a[p1++];//如果第一个序列未检测完,直接将后面所有元素加到合并的序列中
while(p2<=right) tmp[k++]=a[p2++];//同上
//复制回原数组
for (int i = left; i <=right; i++)
a[i]=tmp[i];
}
public static void mergeSort(int [] a,int start,int end){
if(start<end){//当子序列中只有一个元素时结束递归
int mid=(start+end)/2;//划分子序列
mergeSort(a, start, mid);//对左侧子序列进行递归排序
mergeSort(a, mid+1, end);//对右侧子序列进行递归排序
merge(a, start, mid, end);//合并
}
}
//快排,以某个数作为基数,划分成数组,左边子数组每个元素都小于右边数组
public static void quickSort(int[] arr,int low,int high){
int i,j,temp,t;
if(low>high){
return;
}
i=low;
j=high;
temp = arr[low];//temp就是基准位
while (i<j) {
//先看右边,依次往左递减
while (temp<=arr[j]&&i<j) {
j--;
}
//再看左边,依次往右递增
while (temp>=arr[i]&&i<j) {
i++;
}
//如果满足条件则交换
if (i<j) {
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
//最后将基准为与i和j相等位置的数字交换
arr[low] = arr[j];
arr[j] = temp;
//递归调用左半数组
quickSort(arr, low, j-1);
//递归调用右半数组
quickSort(arr, j+1, high);
}
//希尔排序(缩小增量排序),分成几个子序列,对各个子序列之间进行直接插入排序
//设定一个增量,先从array[0]开始以为增量的进行直接插入排序,直到数组末尾..z直到array[n]
//然后取一个小于上一步增量的新的增量,直到增量小于1
public static void shellSort(int [] a) {
int length = a.length;
//increNum增量设置,一般为数组一半
for(int increNum = length/2;increNum>0;increNum/=2) {
for(int i =0; i<length;i++) {
//插入排序,步长为increNum
for (int j = i; j < length-increNum; j+=increNum) {
if(a[j]>a[j+increNum]) {
int temp=a[j];
a[j] = a[j+increNum];
a[j+increNum] = temp;
}
}
}//end for i
}//end for increNum
}// end shellSort
//堆排序,大顶堆(r[i]>=r[2i] && r[i]>=r[2i+1])
//构建堆,将堆顶元素和最后一个元素位置进行交换
public static void maxHeapSort(int [] a) {
int length = a.length;
if(a == null || length <=2) {
return;
}
//变成大根堆
for(int i =0; i < length;i++) {
heapInsert(a,i);
}
for(int i =0; i < length;i++) {
System.out.println("大根堆"+a[i]);
}
// 删除堆顶 自上而下
swap(a, 0, --length);
while(length>0){
heapify(a,0,length);
swap(a, 0, --length);
}
}
public static void heapify(int []a,int index,int length) {
int left = 2*index+1;//左孩子索引值
while(left<length) {
int largest = left+1<length && a[left+1] > a[left]?left+1:left;
largest = a[largest]>a[index]?largest:index;
if(largest == index) break;
swap(a, largest, index);
left = 2*index+1;
}
}
public static void heapInsert(int []a,int i) {
while(a[i]>a[(i-1)/2]) {
swap(a, i, (i-1)/2);
i=(i-1)/2;
}
}
public static void swap(int [] a ,int i ,int j) {
a[i] = a[i] ^ a[j];
a[j] = a[i] ^ a[j];
a[i] = a[i] ^ a[j];
}
public static void main(String [] args) {
int a[] = {5,7,6,0,1,3,2};
// selectSort(a);
// insertSort(a);
// bubbleSort(a);
// mergeSort(a,0,a.length-1);
// quickSort(a,0,a.length-1);
// shellSort(a);
// maxHeapSort(a);
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
System.out.println("\n");
}
}
Java程序员面试笔记_第八章_数据结构和算法_排序
猜你喜欢
转载自blog.csdn.net/hxl0925/article/details/89414508
今日推荐
周排行