冒泡排序
* 冒泡排序需要比较 n(n-1)/2次,时间复杂度O(n^2)
* 稳定排序
* 只需额外一个空间,空间复杂度最佳
* 适用于数据量小或有部分数据已经排过序的情况
*
* 不管数据是否已经完成排序都要执行 n(n-1)/2次
public class BubbleSort {
public static void main(String[] args) {
int i, j ,temp;
int data[] = {6, 5, 9, 7, 2, 8};
System.out.println("冒泡排序法======================");
System.out.print("原始数据为: ");
for (i = 0; i < data.length; i++){
System.out.print(data[i] + " ");
}
System.out.println();
for(i = 5; i > 0; i--){
for(j = 0; j < i; j++){
if (data[j] > data[j+1]) {
temp = data[j];
data[j] = data[j+1];
data[j+1] = temp;
}
}
System.out.print("第" + (6-i) + "次排序后的结果是: ");
for(j = 0; j < data.length; j++){
System.out.print(data[j] + " ");
}
System.out.println();
}
System.out.print("排序后的结果是: ");
for (i = 0; i < data.length; i++){
System.out.print(data[i] + " ");
}
System.out.println();
}
}
冒泡排序增强
* 改良的冒泡排序法
* 普通的冒泡不管数据是否已经完成排序都要执行 n(n-1)/2次
public class BubbleSortPro {
int[] data = new int[] {4, 6, 2, 7, 8, 9};
public static void main(String[] args) {
System.out.print("改良的冒泡排序法\n原始数据为: ");
BubbleSortPro test = new BubbleSortPro();
test.showData();
test.bubblePro();
}
public void showData() {
int i;
for (i = 0; i < 6; i++){
System.out.print(data[i] + " ");
}
System.out.println();
}
public void bubblePro() {
int i, j, temp, flag;
for(i = 5; i > 0; i--){
flag = 0;
for (j = 0; j < i; j++){
if (data[j] > data[j+1]) {
temp = data[j];
data[j] = data[j+1];
data[j+1] = temp;
flag ++;
}
}
if(flag == 0){
break;
}
System.out.print("第" + (6-i) + "次排序后的结果是: ");
for(j = 0; j < data.length; j++){
System.out.print(data[j] + " ");
}
System.out.println();
}
System.out.print("排序结果为: ");
showData();
}
}
堆积排序法
*堆积排序法分析 选择排序的改进
* 二叉树的技巧
* 大->小 最大堆积树 根节点大先取出
* 小->大 最小堆积树 根节点小先取出
*
* 所有情况下,时间复杂度均为O(n log10为底 n)
* 不稳定
* 只需额外一个空间,空间复杂度O(1)
public class HeapSort {
public static void main(String[] args) {
int i, size, data[] = {0, 5, 6, 4, 8, 3, 2, 7, 1};
size = 9;
System.out.print("原始数组:");
for (i = 1 ; i < size; i++){
System.out.print("[" + data[i] +"]");
}
System.out.println();
Heapsort.heap(data, size);
System.out.print("\n排序结果: ");
for (i = 1; i < size; i++){
System.out.print("[" + data[i] + "]");
}
System.out.println();
}
public static void heap(int data[], int size){
int i, j ,temp;
for (i = (size/2); i > 0; i--){
Heapsort.adHeap(data, i, size-1);
}
System.out.print("\n堆积内容:");
for (i = 1; i < size; i++){
System.out.print("[" + data[i] + "]");
}
System.out.println();
for (i = size-2; i > 0; i--){
temp = data[i+1];
data[i+1] = data[1];
data[1] = temp;
Heapsort.adHeap(data, 1, i);
System.out.print("\n处理过程: ");
for (j = 1; j < size; j++){
System.out.print("[" + data[j] + "]");
}
}
}
public static void adHeap(int data[], int i, int size){
int j, temp, post;
j = 2*i;
temp = data[i];
post = 0;
while (j <= size && post == 0){
if(j < size){
if(data[j] < data[j+1]){
j++;
}
}
if(temp >= data[j]){
post = 1;
}else {
data[j/2] = data[j];
j *= 2;
}
}
data[j/2] = temp;
}
}
插入排序法
* 插入排序法分析
* 比较次数 n(n-1)/2次 时间复杂度 O(n^2)
* 稳定排序
* 只需额外一个空间,空间复杂度最佳
* 适用于大部分数据已经排过序或已排序数据库新增数据后进行排序的情况
* 插入排序会造成数据的大量搬移,所以建议链表使用
public class InsertionSort {
int[] data = new int[6];
int size = 6;
public static void main(String[] args) {
InsertionSort test = new InsertionSort();
test.inputarr();
System.out.print("您输入的原始数组是:");
test.showData();
test.insert();
}
public void inputarr() {
int i;
for(i = 0; i < size; i++){
try {
System.out.println("请输入第" + (i+1) + "个元素:");
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
data[i] = Integer.parseInt(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void showData() {
int i;
for (i = 0; i < size; i++){
System.out.print(data[i] + " ");
}
System.out.println();
}
public void insert(){
int i, j, temp;
for(i = 1; i <size; i++){
temp = data[i];
j = i-1;
while (j >= 0 && temp < data[j]){
data[j+1] = data[j];
j--;
}
data[j+1] = temp;
System.out.println("第" + i + "次扫描:");
showData();
}
}
}
快速排序法
* 快速排序法分析 又叫分隔交换排序法’
* 最快及平均的时间复杂度为O(nlog2为底 n) 最坏就是每次挑中的中间值不是最大就是最小,时间复杂度为O(n^2)
* 不稳定
* 最差空间复杂度为O(n) 最好O(log2为底 n)
* 平均运行时间最快的排序法
public class QuickSort {
int process = 0;
int size;
int[] data = new int[100];
public static void main(String[] args) {
QuickSort test = new QuickSort();
System.out.print("请输入数组的大小(100以下):");
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
test.size = Integer.parseInt(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
test.inputarr();
System.out.print("原始数组数据是;");
test.showData();
test.quick(test.data, test.size, 0, test.size-1);
System.out.print("\n排序结果是:");
test.showData();
}
public void inputarr(){
Random rand = new Random();
int i;
for(i = 0; i < size; i++){
data[i] = (Math.abs(rand.nextInt(99)))+1;
}
}
public void showData() {
int i;
for (i = 0; i < size; i++){
System.out.print(data[i] + " ");
}
System.out.println();
}
public void quick(int d[], int size, int lf, int rg){
int i, j, temp;
int lfIdx, rgIdx;
int t;
if(lf < rg){
lfIdx = lf+1;
rgIdx = rg;
while(true){
System.out.print("[处理过程" + (process++) + "]=>");
for (t = 0; t < size; t++){
System.out.print("[" + d[t] + "] ");
}
System.out.println();
for(i = lf+1; i <= rg; i++){
if(d[i] >= d[lf]){
lfIdx = i;
break;
}
lfIdx++;
}
for(j = rg; j >= lf+1; j--){
if(d[j] <= d[lf]){
rgIdx = j;
break;
}
rgIdx--;
}
if(lfIdx < rgIdx){
temp = d[lfIdx];
d[lfIdx] = d[rgIdx];
d[rgIdx] = temp;
}else {
break;
}
}
if(lfIdx >= rgIdx){
temp = d[lf];
d[lf] = d[rgIdx];
d[rgIdx] = temp;
quick(d, size, lf, rgIdx-1);
quick(d, size, rgIdx+1, rg);
}
}
}
}
基数排序法
* 基数排序法分析
* 按照最高为优先:最左边的位数开始比较 最低为优先:最右边的位数开始比较 两种
* 在所有的情况下时间复杂度均为O(n log p为底 k),k为院原始数据最大值
* 稳定
* 很大的额外存储空间,空间复杂度O(n*p),n 是原始数据的个数,p 是数据字符数
* 若n很大, p固定或者很小,则该方法很有效率
public class RadixSort {
int size;
int[] data = new int[100];
public static void main(String[] args) {
RadixSort test = new RadixSort();
System.out.print("请输入数组的大小(100以下)");
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
test.size = Integer.parseInt(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
test.inputarr();
System.out.print("原始数组数据是;");
test.showData();
test.radix();
}
public void inputarr(){
Random rand = new Random();
int i;
for(i = 0; i < size; i++){
data[i] = (Math.abs(rand.nextInt(999)))+1;
}
}
public void showData() {
int i;
for (i = 0; i < size; i++){
System.out.print(data[i] + " ");
}
System.out.println();
}
public void radix(){
int i, j ,k, n, m;
for (n = 1; n <= 100; n *= 10){
int[][] temp = new int [10][100];
for (i = 0; i < size; i++){
m = (data[i]/n) % 10;
temp[m][i] = data[i];
}
k = 0;
for (i = 0; i < 10; i++){
for (j = 0; j < size; j++){
if (temp[i][j] != 0){
data[k] = temp[i][j];
k++;
}
}
}
System.out.print("经过" + n + "位数排序后: ");
showData();
}
}
}
选择排序法
*选择排序的分析
* 比较次数 n(n-1)/2次 时间复杂度 O(n^2)
* 不稳定
* 只需额外一个空间,空间复杂度最佳
* 适用于数据量小或有部分数据已经排过序的情况
public class SelectionSort {
int[] data = new int[] {9, 7, 5, 3, 4, 6};
public static void main(String[] args) {
System.out.print("原始数据为: ");
SelectionSort test = new SelectionSort();
test.showData();
test.select();
}
public void showData() {
int i;
for (i = 0; i < 6; i++){
System.out.print(data[i] + " ");
}
System.out.println();
}
public void select() {
int i, j, temp, k;
for(i = 0; i < 5; i++){
for(j = i+1; j < 6; j++){
if(data[i] > data[j]){
temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
System.out.print("第" + (i+1) + "次排序后的结果是: ");
for(k = 0; k < 6; k++){
System.out.print(data[k] + " ");
}
System.out.println();
}
System.out.print("排序结果为: ");
showData();
}
}
希尔排序法
* 希尔排序分析
* 像插入排序,但可以减少次数,不同:将数据区分成特定间隔的几个小块,以插入排序法排完区块内的数据后再渐渐减少间隔的距离
* 任何情况下时间复杂度都是 O(n ^3/2)
* 稳定排序
* 只需额外一个空间,空间复杂度最佳
* 适用于大部分数据都已排序完成的情况
public class ShellSort {
int[] data = new int[8];
int size = 8;
public static void main(String[] args) {
ShellSort test = new ShellSort();
test.inputarr();
System.out.print("您输入的原始数组:");
test.showData();
test.shell();
}
public void inputarr() {
int i;
for(i = 0; i < size; i++){
try {
System.out.println("请输入第" + (i+1) + "个元素:");
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
data[i] = Integer.parseInt(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void showData() {
int i;
for (i = 0; i < size; i++){
System.out.print(data[i] + " ");
}
System.out.println();
}
public void shell(){
int i, j;
int k = 1;
int temp;
int jmp;
jmp = size / 2;
while (jmp != 0){
for(i = jmp; i < size; i++){
temp = data[i];
j = i-jmp;
while (j >= 0 && temp < data[j]){
data[j + jmp] = data[j];
j = j-jmp;
}
data[jmp+j] = temp;
}
System.out.println("第" + (k++) + "次排序");
showData();
jmp /= 2;
}
}
}