排序算法实现原理及demo

一、冒泡排序

   外层循环循环当前数组，内层循环循环当前数组-i-1。
   核心思想:第一次将最大数字移动到最后，第二次将第二大数字移动到最后，依次循环，直至最后一个数字在最前面。

冒泡排序demo

public class BubbleSort {

    public static void main(String[] args) {
        int[] arr = {9,5,1,2};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if(arr[j]>arr[j+1]){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

二、插入排序

  先将数组分为两部分（从第二个元素开始循环，第一次第一个元素是一组，其他元素为一组），然后循环将后面的元素放置第一个数组中进行比较，做排序，再将第三个元素放进前面的数组中进行排序，依次类推，直至最后一个元素比较完成。

插入排序原理引用文章

插入排序demo

 public class insertSort {
    public static void main(String[] args) {
        int[] arr={5,3,2,4,6,8,7,1};
        insertSortDemo(arr);    
    }

    public static void insertSortDemo(int[] arr){
        for (int i=1;i< arr.length;i++){
            int temp=arr[i];
            int index=i;
            for (int j=i-1;j>=0;j--){
                if(temp<arr[j]){
                    swap(arr,index,j);
                    index=j;
                }
            }
            System.out.println(Arrays.toString(arr));
        }
    }

    public static void swap(int[] arr,int x,int y){
        int temp=arr[x];
        arr[x]=arr[y];
        arr[y]=temp;
    }
}

三、希尔排序

希尔排序实现原理及demo

四、归并排序

java归并排序demo及原理

五、快速排序

快速排序demo

void quickSort(int *arr,int begin,int end)
{
	//如果区间不只一个数
	if(begin < end)
	{
		int temp = arr[begin]; //将区间的第一个数作为基准数
		int i = begin; //从左到右进行查找时的“指针”，指示当前左位置
		int j = end; //从右到左进行查找时的“指针”，指示当前右位置
		//不重复遍历
		while(i < j)
		{
			//当右边的数大于基准数时，略过，继续向左查找
			//不满足条件时跳出循环，此时的j对应的元素是小于基准元素的
			while(i<j && arr[j] > temp)
				j--;
			//将右边小于等于基准元素的数填入右边相应位置
			arr[i] = arr[j];
			//当左边的数小于等于基准数时，略过，继续向右查找
			//(重复的基准元素集合到左区间)
			//不满足条件时跳出循环，此时的i对应的元素是大于等于基准元素的
			while(i<j && arr[i] <= temp)
				i++;
			//将左边大于基准元素的数填入左边相应位置
			arr[j] = arr[i];
		}
		//将基准元素填入相应位置
		arr[i] = temp;
		//此时的i即为基准元素的位置
		//对基准元素的左边子区间进行相似的快速排序
		quickSort(arr,begin,i-1);
		//对基准元素的右边子区间进行相似的快速排序
		quickSort(arr,i+1,end);
	}
	//如果区间只有一个数，则返回
	else
		return;
}
int main()
{
	int num[12] = {23,45,17,11,13,89,72,26,3,17,11,13};
	int n = 12;
	quickSort(num,0,n-1);
	cout << "排序后的数组为：" << endl;
	for(int i=0;i<n;i++)
		cout << num[i] << ' ';
	cout << endl;
	system("pause");
	return 0;
}

快速排序原理及demo

六、基数排序

基数排序原理动图展示

基数排序demo

public class RadixSort {
    public static void main(String[] args) {
        int arr[] = {53, 3, 542, 748, 14, 214};
        radixSort(arr);
    }
 
    public static void radixSort(int[] arr) {
        //得到数组中最大的数的位数
        int maxNum = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maxNum) {
                maxNum = arr[i];
            }
        }
        //得到最大数是几位数
        int maxLength = (maxNum + "").length();
 
        //定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
        int[][] bucket = new int[10][arr.length];
        //每个桶存入了几个数字
        int[] everyBucketNum = new int[10];
 
        // n* = 10 的原因是
        //123取出个位数字是 123 % 10，即 123 / 1 %10
        //123 取出十位数字是123 / 10 % 10;
        //123 去除百位数字是123 /100 % 10
        //以此类推
        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素的对应位的值
                int digit = arr[j] / n % 10;
                //放入到对应的桶中
                bucket[digit][everyBucketNum[digit]] = arr[j];
                everyBucketNum[digit]++;
            }
            //按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
            int index = 0;
            //遍历每一桶，并将桶中是数据，放入到原数组
            for (int k = 0; k < everyBucketNum.length; k++) {
                if (everyBucketNum[k] != 0) {
                    for (int l = 0; l < everyBucketNum[k]; l++) {
                        arr[index++] = bucket[k][l];
                    }
                }
                //放回原数组后，需要将每个 everyBucketNum[k] = 0
                everyBucketNum[k] = 0;
 
            }
            System.out.println("第" + (i + 1) + "轮，对个位的排序处理 arr =" + Arrays.toString(arr));
 
        }
    }
}

基数排序原理及demo