1.冒泡排序：
（1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。
（2）外面再套个循环就行。
算法复杂度：O(N2) 不罗嗦，上代码：
//冒泡排序（两两交换，外加一个外循环）
public static void bubbleSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=0;i<len-1;i++){
for (j=1;j<len-i;j++){
if (sortData[j-1] > sortData[j]){
swap(sortData,j-1,j);
}
}
}
}
2. 选择排序
（1）每次从剩下无序中选择最小的元素，进行交换
算法复杂度：O(N2) 不罗嗦，上代码：
//选择排序（从剩下的选最大的交换）
public static void selectionSort(int sortData[]){
int i,j,min,index,temp;
int len = sortData.length;
for (i=0;i<len;i++){
min = sortData[i];
index = i;
for (j=i+1;j<len;j++){
if (sortData[j] < min){
min = sortData[j];
index = j;
}
}
swap(sortData,i,index);
}
}
3.插入排序：
（1）基本操作就是将一个数据插入到已经排好序的有序数据中：
//插入排序，把大的往后移动
public static void insertSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=1;i<len;i++){
temp = sortData[i];
for (j = i-1;j>=0 && temp < sortData[j];j--){
sortData[j+1] = sortData[j];
}
sortData[j+1] = temp;
}
}
3.希尔排序：
是插入排序的改进版，主要是希尔通过引入增量，加强了插入排序的威力。随着增量的减少，就有序了。
//希尔排序
public static void shellSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
int gap = len/2;
while(gap>=1){
for (i=gap;i<len;i++){
temp = sortData[i];
for (j=i-gap;j>=0&&temp<sortData[j];j=j-gap){
sortData[j+gap] = sortData[j];
}
sortData[j+gap] = temp;
}
gap = gap/2;
}
}
4.堆排序
（1）初始堆 （2）adjust到最小堆或最大堆的格式 （3）排序，根位置和最后一个位置换一下位置，再adjust。
public static void heapSort(int sortData []){
buildMaxHeap(sortData);
for(int i=sortData.length-1;i>=1;i--){
swap(sortData,0,i);
maxHeap(sortData,i,0);
}
}
public static void buildMaxHeap(int sortData[]){
int half = sortData.length/2;
for(int i=half;i>=0;i--){
maxHeap(sortData,sortData.length,i);
}
}
public static void maxHeap(int sortData[],int heapSize,int index){
int left = 2*index+1;
int right = 2*index+2;
int largest = index;
if (left < heapSize && sortData[left]>sortData[index]){
largest = left;
}
if(right < heapSize && sortData[right]>sortData[index]){
largest = right;
}
if (index != largest){
swap(sortData,index,largest);
maxHeap(sortData,heapSize,largest);
}
}
5. 快速排序：
其实是二分法，一般来说以第一个位置做为分界点，把小的放到这个分界点前面，大的放到后面。递归这两部分。
//快速排序
public static void quickSort(int sortData[],int start,int end){
if (start >=end) return;
int i=start,j=end,value = sortData[i];
boolean flag = true;
while(i!=j){
if (flag){
if (value > sortData[j]){
swap(sortData,i,j);
flag=false;
}else{
j--;
}
}else{
if (value<sortData[i]){
swap(sortData,i,j);
flag=true;
}else{
i++;
}
}
}
//printValue(sortData);
quickSort(sortData,start,j-1);
quickSort(sortData,i+1,end);
}
所有可运行代码：
//gjs
public class sort {
public static void printValue(int sortData[]){
for (int i = 0;i<sortData.length;i++){
System.out.print(sortData[i]+" ");
}
System.out.println();
}
public static void swap(int [] data ,int pos1, int pos2){
int temp = data[pos1];
data[pos1] = data[pos2];
data[pos2] = temp;
}
//冒泡排序（两两交换，外加一个外循环）
public static void bubbleSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=0;i<len-1;i++){
for (j=1;j<len-i;j++){
if (sortData[j-1] > sortData[j]){
swap(sortData,j-1,j);
}
}
}
}
//选择排序（从剩下的选最大的交换）
public static void selectionSort(int sortData[]){
int i,j,min,index,temp;
int len = sortData.length;
for (i=0;i<len;i++){
min = sortData[i];
index = i;
for (j=i+1;j<len;j++){
if (sortData[j] < min){
min = sortData[j];
index = j;
}
}
swap(sortData,i,index);
}
}
//插入排序，把大的往后移动
public static void insertSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=1;i<len;i++){
temp = sortData[i];
for (j = i-1;j>=0 && temp < sortData[j];j--){
sortData[j+1] = sortData[j];
}
sortData[j+1] = temp;
}
}
//希尔排序
public static void shellSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
int gap = len/2;
while(gap>=1){
for (i=gap;i<len;i++){
temp = sortData[i];
for (j=i-gap;j>=0&&temp<sortData[j];j=j-gap){
sortData[j+gap] = sortData[j];
}
sortData[j+gap] = temp;
}
gap = gap/2;
}
}
public static void heapSort(int sortData []){
buildMaxHeap(sortData);
for(int i=sortData.length-1;i>=1;i--){
swap(sortData,0,i);
maxHeap(sortData,i,0);
}
}
public static void buildMaxHeap(int sortData[]){
int half = sortData.length/2;
for(int i=half;i>=0;i--){
maxHeap(sortData,sortData.length,i);
}
}
public static void maxHeap(int sortData[],int heapSize,int index){
int left = 2*index+1;
int right = 2*index+2;
int largest = index;
if (left < heapSize && sortData[left]>sortData[index]){
largest = left;
}
if(right < heapSize && sortData[right]>sortData[index]){
largest = right;
}
if (index != largest){
swap(sortData,index,largest);
maxHeap(sortData,heapSize,largest);
}
}
//快速排序
public static void quickSort(int sortData[],int start,int end){
if (start >=end) return;
int i=start,j=end,value = sortData[i];
boolean flag = true;
while(i!=j){
if (flag){
if (value > sortData[j]){
swap(sortData,i,j);
flag=false;
}else{
j--;
}
}else{
if (value<sortData[i]){
swap(sortData,i,j);
flag=true;
}else{
i++;
}
}
}
//printValue(sortData);
quickSort(sortData,start,j-1);
quickSort(sortData,i+1,end);
}
public static void main(String[] args) {
int [] a={2,4,1,5,8,9,43,3,7,8,9,0,3};
printValue(a);
//bubbleSort(a);
//selectionSort(a);
//insertSort(a);
//heapSort(a);
//shellSort(a);
quickSort(a,0,a.length-1);
printValue(a);
}
}
时间： 2024-08-30 00:18:27