基础排序算法，java实现（快速，冒泡，选择，堆排序，插入）

1.冒泡排序：

（1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。

　　（2）外面再套个循环就行。

算法复杂度：O(N²) 不罗嗦，上代码：

	//冒泡排序（两两交换，外加一个外循环）
	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(N²) 不罗嗦，上代码：　　

    //选择排序（从剩下的选最大的交换）
    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。

利用最大堆，最小堆这一特性，使得每次从无序的列表中选择最大或者最小的数据。

其基本思想为(大顶堆)：

1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；

2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n];

3)由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

　　1）运行时间消耗：构建初始堆和重建堆的反复筛选上。

构建堆：

　　每次从最下层的最右边的非终端节点构建，将他和期孩子节点进行比较，每次最多进行两次比较和交互，因此这个构建时间是N

重建堆（排序）：

第i次取堆顶需要logi，那么要去n-1次，所以时间复杂度是nlogn

由于堆排序对原始记录的排序状态并不敏感，因此它无论是最好、最坏和平均时间复杂度均为O(nlogn)。

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[largest]){
			largest = right;
		}
		if (index != largest){
			swap(sortData,index,largest);
			maxHeap(sortData,heapSize,largest);
		}
	
	}

　　5. 快速排序：

其实是二分法，一般来说以第一个位置做为分界点，把小的放到这个分界点前面，大的放到后面。递归这两部分。

基本思想：选择一个基准元素，通常是选取第一个或者最后一个元素，通过一趟扫描，将待排序的序列分成两部分，一部分比基准元素小，一部分比基准元素大。此时基准元素就在排好序的正确位置。然后采用相同的方法，递归排序划分左右数据。

算法复杂度：平均和最好都是： nlog（n）最坏情况（逆序）： n2 不稳定

	//快速排序
	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);
	}

c++

//快排
void qsort(int a[],int low,int high){
	if (low >= high) return;
	int first = low;
	int last = high;
	int key = a[first];

	while(first<last){
		while(first<last && a[last]>=key) --last;
		a[first] = a[last];
		while(first<last && a[first]<=key) ++first;
		a[last] = a[first];
	}
	a[first] = key;
	qsort(a,low,first-1);
	qsort(a,first+1,high);
}

6 归并排序 c++

void merge(int array[],int low,int mid,int high){
	int i = low;
	int j = mid+1;
	int k = 0;
	int *array2 = new int [high-low+1];
	while(i <= mid && j <= high){
		if (array[i] < array[j]){
			array2[k] = array[i];
			i++;
			k++;
		}else{
			array2[k] = array[j];
			j++;
			k++;
		}
	}

	while(i <= mid){
		array2[k] = array[i];
		k++;
		i++;
	}
	while(j <= high){
		array2[k] = array[j];
		k++;
		j++;
	}
	for(k=0,i=low;i<=high;i++,k++){
		array[i] = array2[k];
	}

}


void mergeSort(int a[],int low,int high){
	if (low<high){
		int mid = (low+high)/2;
		mergeSort(a,low,mid);
		mergeSort(a,mid+1,high);
		merge(a,low,mid,high);
	}
}


int main(){

	int arr [10] = {3,4,2,4,6,2,5,7,0,2};
	int len;
	ARR_LEN(arr,len);
	mergeSort(arr,0,len-1);
	for(auto x: arr){
		cout << x << " ";
	}


}

所有可运行代码：

//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);
        

    }

}

转载于:https://www.cnblogs.com/GuoJiaSheng/p/5250704.html

基础排序算法，java实现（快速，冒泡，选择，堆排序，插入）

猜你喜欢