基础排序算法,java实现(快速,冒泡,选择,堆排序,插入)

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-11-05 22:48:02

基础排序算法,java实现(快速,冒泡,选择,堆排序,插入)的相关文章

八大内部排序算法(上)-冒泡、直接插入、简单选择、快速

八大内部排序算法(上)冒泡.直接插入.简单选择.快速 排序分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存. 我们这里说说八大排序就是内部排序. 1.直接插入排序 将一个记录插入到已排序好的有序表中,从而得到一个新,记录数增1的有序表.即:先将序列的第1个记录看成是一个有序的子序列,然后从第2个记录逐个进行插入,直至整个序列有序为止. 要点:设立哨兵,作为临时存储和判断数组边界之用. 直接插入实现如下:

九大基础排序算法总结

九大基础排序算法小结 一直想做份总结,总是抽不出时间,趁着周末闲着直接用了一整天做一份,一些内容参考了网上的一些博主的总结,还有网络上的一些图片. 好了,接下来就看看内容吧! 排序算法: 排序方法 时间复杂度 空间复杂度 稳定性 选用情况 平均情况 最坏情况 最好情况 Insertion Sort O(n^2) O(n^2) O(n) O(1) 稳定 n较小时 Selection Sort O(n^2) O(n^2) O(n^2) O(1) 不稳定 n较小时 Bubble Sort O(n^2)

基础排序算法 c#

算法知识欠缺,学习几种基础排序算法,1. 选择排序  2.冒泡排序 3.插入排序 以升序为例,程序中凡是 两个值的比较前者大于后者,则调换位置 1. 选择排序 最容易想到的排序算法,但却不知道这种叫做选择排序法 1 /// <summary> 2 /// 选择排序 3 /// </summary> 4 /// <param name="sourceValues"></param> 5 /// <returns></ret

排序算法Java实现

排序算法Java实现 排序算法的分类: 内部排序,在排序过程中,全部记录放在内存中,称为内部排序: 外部排序,在排序过程中需要使用外部存储(磁盘),则称为外部排序. 主要介绍内部排序: 插入排序:直接插入排序.二分法插入排序.希尔排序 选择排序:简单选择排序.堆排序 交换排序:冒泡排序.快速排序 归并排序 基数排序 插入排序 直接插入排序 基本思想:对于给定的一组记录,初始时假设第一个记录自成一个有序序列,其余记录为无序序列.接着从第二个记录开始,按照记录的大小依次将当前处理的记录插入到其之前的

基础排序算法

七个基础排序算法(均为内部排序): 直接插入排序 希尔排序 冒泡排序 简单选择排序 快速排序 堆排序 二路归并排序 排序算法稳定性:经过排序后,具有相同关键码的元素之间的相对次序保持不变,则称该排序方法是稳定的;否则不稳定. 直接插入排序: void InsertSort(int a[],int n){ // index start at 1, a[0] is temp one int i,j; for(i=2;i<=n;i++){ if(a[i]<a[i-1]){ a[0]=a[i]; a[

八大排序算法JAVA实现(时间复杂度O(n*logn)篇)

本文讲述时间复杂度为n*logn的排序算法:归并排序.快速排序.堆排序以及希尔排序的原理.Java实现以及变形应用. 一.归并排序 原理:把两个有序数列合并为一个有序数列.需递归实现. Java实现: 1 public int[] mergeSort(int[] a, int n) 2 { 3 return doMergeSort(a, n, 0, n - 1); 4 } 5 public int[] doMergeSort(int[] a, int n, int start, int end)

php四种基础排序算法的运行时间比较!

/** * php四种基础排序算法的运行时间比较 * @authors Jesse (jesse152@163.com) * @date 2016-08-11 07:12:14 */ //冒泡排序法 function bubbleSort($array){ $temp = 0; for($i = 0;$i < count($array) -1;$i++){ for($j = 0;$j < count($array) - 1 -$i;$j++){ if($array[$j] > $arra

经典排序算法(Java实现)

以下程序均将数据封装于DataWrap数据包装类中,如下所示: 1 //数据包装类 2 class DataWrap implements Comparable<DataWrap> 3 { 4 int data; 5 String flag; 6 public DataWrap(int data,String flag) 7 { 8 this.data = data; 9 this.flag = flag; 10 } 11 //重写compareTo方法 12 public int compa

php四种基础排序算法的运行时间比较

/** * php四种基础排序算法的运行时间比较 * @authors Jesse (jesse152@163.com) * @date 2016-08-11 07:12:14 */ //冒泡排序法 function bubbleSort($array){ $temp = 0; for($i = 0;$i < count($array) -1;$i++){ for($j = 0;$j < count($array) - 1 -$i;$j++){ if($array[$j] > $arra

数据结构排序算法Java实现

闲的无聊又拿起了大学的数据结构的书看起来 <数据结构(c语言版)>严蔚敏 吴伟民编著. 里面有几个排序算法,感觉挺好玩的,就想着写出来玩玩. package test.sort; /** * @Title: TODO * @Description: TODO * @author: * @date: 2014-8-10 上午11:20:43 * */ public class quickSort { private static int datas[] = {23,42,12,45,56,63,