java排序算法实现代码

• Z时代
• 2024-01-10
• 分类：综合

JAVA排序算法实现代码-快速(Quick Sort)排序

1. /**  
2.  * JAVA排序算法实现代码-快速(Quick Sort)排序。  
3.  *   
4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
5.  *   
6.  */  

7. public class Test {   

8.   public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   

9.   

10.   public static void main(String args[]) {   

11.   

12.     System.out.print("排序前: ");   

13.     for (int i = 0; i < a.length; i++)   

14.       System.out.printf("%3s", a[i]);   

15.   

16.     System.out.println("");   

17.   

18.     int Index = a.length;   

19.   

20.     QuickSort(0, Index - 1, Index); // 快速排序   

21.   

22.     // 排序后结果   

23.     System.out.print("排序后: ");   

24.     for (int i = 0; i < a.length; i++)   

25.       System.out.printf("%3s", a[i]);   

26.   

27.     System.out.println("");   

28.   }   
29.   

30.   public static void QuickSort(int Left, int Right, int Index) {   

31.     int i, j, k; // 循环计数变量   

32.     int Pivot; // 枢纽变量   

33.     int Temp; // 暂存变量   

34.   

35.     i = Left; // 设定左指针   

36.     j = Right; // 设定右指针   

37.   

38.     Pivot = a[Left]; // 取最左边的元素   

39.   

40.     if (i < j) {   

41.       do {   

42.         while (a[i] <Pivot && i < Right) // 从左往右找比Pivot大的值   

43.         {   
44.           i++;   
45.         }   

46.         while (a[j] > Pivot && j > Left) // 从右往左找比Pivot小的值   

47.         {   
48.           j--;   
49.         }   
50.   

51.         if (i < j) // 交换a[i]和a[j]   

52.         {   
53.           Temp = a[i];   
54.           a[i] = a[j];   
55.           a[j] = Temp;   
56.         }   

57.       } while (i < j);   

58.       if (i > j) {   

59.         Temp = a[Left]; // 交换a[Left]和a[j]   

60.         a[Left] = a[j];   
61.         a[j] = Temp;   
62.   

63.         // 打印目前排序结果   

64.   

65.         System.out.print("排序中: ");   

66.         for (k = 0; k <= Index; k++) {   

67.           System.out.printf("%3s", a[k]);   

68.         }   

69.         System.out.println("");   

70.       }   

71.       QuickSort(Left, j - 1, Index); // 排序左半边   

72.       QuickSort(j + 1, Right, Index); // 排序右半边   

73.     }   
74.   }   
75. }  

运行结果
排序前: 10 32 1 9 5 7 12 0 4 3
排序后: 0 1 3 4 5 7 9 10 12 32

JAVA排序算法实现代码-冒泡(Bubble Sort)排序

1. /**  
2.  * JAVA排序算法实现代码-冒泡(Bubble Sort)排序。  
3.  *   
4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
5.  *   
6.  */  

7. public class Test {   

8.   public static void main(String[] args) {   

9.     int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 };   

10.   

11.     System.out.print("排序前: ");   

12.   

13.     for (int i = 0; i < a.length; i++)   

14.       System.out.printf("%3s", a[i]);   

15.   
16.     System.out.println();   
17.   

18.     Test test = new Test();   

19.     test.bubbleSort(a);   
20.   

21.     System.out.print("排序后: ");   

22.   

23.     for (int i = 0; i < a.length; i++)   

24.       System.out.printf("%3s", a[i]);   

25.   
26.     System.out.println();   
27.   }   
28.   

29.   public void bubbleSort(int[] a) {   

30.     int len = a.length;   

31.   

32.     System.out.println("数组大小是:" + len);   

33.   

34.     boolean change = false;   

35.     int temp;   

36.     int count = 0;   

37.   

38.     for (int i = len; i > 1; i--) {   

39.       for (int j = 0; j < i - 1; j++) {   

40.         if (a[j + 1] < a[j]) {   

41.           temp = a[j + 1];   

42.           a[j + 1] = a[j];   

43.           a[j] = temp;   

44.           change = true;   

45.           count++;   
46.         }   
47.   
48.       }   

49.       if (change) {   

50.         System.out.print("第" + count + "趟交换:  ");   

51.         for (int k = 0; k < len; k++)   

52.           System.out.print(a[k] + " ");   

53.   
54.         System.out.println();   
55.       }   
56.     }   
57.   }   
58. }  

运行结果
排序前: 10 32 1 9 5 7 12 0 4 3
数组大小是:10
第8趟交换: 10 1 9 5 7 12 0 4 3 32
第15趟交换: 1 9 5 7 10 0 4 3 12 32
第20趟交换: 1 5 7 9 0 4 3 10 12 32
第23趟交换: 1 5 7 0 4 3 9 10 12 32
第26趟交换: 1 5 0 4 3 7 9 10 12 32
第29趟交换: 1 0 4 3 5 7 9 10 12 32
第31趟交换: 0 1 3 4 5 7 9 10 12 32
第31趟交换: 0 1 3 4 5 7 9 10 12 32
第31趟交换: 0 1 3 4 5 7 9 10 12 32
排序后: 0 1 3 4 5 7 9 10 12 32

JAVA排序算法实现代码-堆(Heap)排序

1. /**  
2.  * JAVA排序算法实现代码-堆(Heap)排序。  
3.  *   
4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
5.  *   
6.  */  

7. public class Test {   

8.   public static int[] Heap = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   

9.   

10.   public static void main(String args[]) {   

11.     int i; // 循环计数变量   

12.     int Index = Heap.length; // 数据索引变量   

13.   

14.     System.out.print("排序前: ");   

15.     for (i = 1; i < Index - 1; i++)   

16.       System.out.printf("%3s", Heap[i]);   

17.     System.out.println("");   

18.   

19.     HeapSort(Index - 2); // 堆排序   

20.   

21.     System.out.print("排序后: ");   

22.     for (i = 1; i < Index - 1; i++)   

23.       System.out.printf("%3s", Heap[i]);   

24.     System.out.println("");   

25.   }   
26.   

27.   /**  

28.    * 建立堆  
29.    */  

30.   public static void CreateHeap(int Root, int Index) {   

31.     int i, j; // 循环计数变量   

32.     int Temp; // 暂存变量   

33.     int Finish; // 判断堆是否建立完成   

34.   

35.     j = 2 * Root; // 子节点的Index   

36.     Temp = Heap[Root]; // 暂存Heap的Root 值   

37.     Finish = 0; // 预设堆建立尚未完成   

38.   

39.     while (j <= Index && Finish == 0) {   

40.       if (j < Index) // 找最大的子节点   

41.         if (Heap[j] < Heap[j + 1])   

42.           j++;   

43.       if (Temp >= Heap[j])   

44.         Finish = 1; // 堆建立完成   

45.       else {   

46.         Heap[j / 2] = Heap[j]; // 父节点 = 目前节点   

47.         j = 2 * j;   

48.       }   
49.     }   

50.     Heap[j / 2] = Temp; // 父节点 = Root值   

51.   }   
52.   

53.   public static void HeapSort(int Index) {   

54.     int i, j, Temp;   

55.     // 将二叉树转成Heap   

56.     for (i = (Index / 2); i >= 1; i--)   

57.       CreateHeap(i, Index);   
58.   

59.     // 开始进行堆排序   

60.     for (i = Index - 1; i >= 1; i--) {   

61.       Temp = Heap[i + 1]; // Heap的Root值和最后一个值交换   

62.       Heap[i + 1] = Heap[1];   

63.       Heap[1] = Temp;   

64.       CreateHeap(1, i); // 对其余数值重建堆   

65.   

66.       System.out.print("排序中: ");   

67.       for (j = 1; j <= Index; j++)   

68.         System.out.printf("%3s",Heap[j]);   

69.       System.out.println("");   

70.     }   
71.   }   
72. }  

运行结果
排序前: 32 1 9 5 7 12 0 4
排序中: 12 7 9 5 1 4 0 32
排序中: 9 7 4 5 1 0 12 32
排序中: 7 5 4 0 1 9 12 32
排序中: 5 1 4 0 7 9 12 32
排序中: 4 1 0 5 7 9 12 32
排序中: 1 0 4 5 7 9 12 32
排序中: 0 1 4 5 7 9 12 32
排序后: 0 1 4 5 7 9 12 32

JAVA排序算法实现代码-选择(Select)式排序

1. /**  
2.  * JAVA排序算法实现代码-选择(Select)式排序。  
3.  *   
4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
5.  *   
6.  */  

7. public class Test {   

8.   public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   

9.   

10.   public static void main(String args[]) {   

11.     int i; // 循环计数变量   

12.     int Index = a.length;// 数据索引变量   

13.   

14.     System.out.print("排序前: ");   

15.     for (i = 0; i < Index - 1; i++)   

16.       System.out.printf("%3s", a[i]);   

17.     System.out.println("");   

18.   

19.     SelectSort(Index - 1); // 选择排序   

20.     // 排序后结果   

21.     System.out.print("排序后: ");   

22.     for (i = 0; i < Index - 1; i++)   

23.       System.out.printf("%3s", a[i]);   

24.     System.out.println("");   

25.   }   
26.   

27.   public static void SelectSort(int Index) {   

28.     int i, j, k; // 循环计数变量   

29.     int MinValue; // 最小值变量   

30.     int IndexMin; // 最小值索引变量   

31.     int Temp; // 暂存变量   

32.   

33.     for (i = 0; i < Index - 1; i++) {   

34.       MinValue = 32767; // 目前最小数值   

35.       IndexMin = 0; // 储存最小数值的索引值   

36.       for (j = i; j < Index; j++) {   

37.         if (a[j] < MinValue) // 找到最小值   

38.         {   

39.           MinValue = a[j]; // 储存最小值   

40.           IndexMin = j;   
41.         }   

42.         Temp = a[i]; // 交换两数值   

43.         a[i] = a[IndexMin];   
44.         a[IndexMin] = Temp;   
45.       }   
46.   

47.       System.out.print("排序中: ");   

48.       for (k = 0; k < Index; k++)   

49.         System.out.printf("%3s", a[k]);   

50.       System.out.println("");   

51.     }   
52.   }   
53. }  

运行结果
排序前: 10 32 1 9 5 7 12 0 4
排序中: 1 32 10 9 5 7 12 0 4
排序中: 1 5 32 10 9 7 12 0 4
排序中: 1 5 9 32 10 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序后: 1 5 9 10 32 7 12 0 4

JAVA排序算法实现代码-二叉树排序

1. /**  
2.  * JAVA排序算法实现代码-二叉树排序。  
3.  *   
4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
5.  *   
6.  */  

7. public class Test {   

8.   public static int[] a = { 0, 10, 32, 1, 9, 5, 7, 12, 2, 4, 3 }; // 预设数据数组   

9.   public static int[] Data = new int[20]; // 预设数据数组   

10.   

11.   public static void main(String args[]) {   

12.     int i; // 循环计数变量   

13.     int Index = 1; // 数据索引变量   

14.     BNTreeArray BNTree = new BNTreeArray(); // 声明二叉树数组   

15.   
16.     Data[Index] = a[Index];   

17.     BNTreeArray.TreeData[0] = Data[Index];   

18.     Index++;   

19.     for (i = 2; i < a.length; i++) {   

20.       Data[Index] = a[Index];   

21.       BNTree.Create(Data[Index]); // 建立二叉查找树   

22.       Index++;   
23.     }   
24.   

25.     // 排序前数据内容   

26.     System.out.print("排序前 : ");   

27.     for (i = 1; i < Index; i++)   

28.       System.out.print(" " + Data[i] + " ");   

29.     System.out.println("");   

30.   

31.     // 排序后结果   

32.     System.out.print("排序后 : ");   

33.     BNTreeArray.InOrder(0); // 中序遍历   

34.   }   
35. }   
36.   

37. class BNTreeArray {   

38.   public static int MaxSize = 20;   

39.   public static int[] TreeData = new int[MaxSize];   

40.   public static int[] RightNode = new int[MaxSize];   

41.   public static int[] LeftNode = new int[MaxSize];   

42.   

43.   public BNTreeArray() {   

44.     int i; // 循环计数变量   

45.   

46.     for (i = 0; i < MaxSize; i++) {   

47.       TreeData[i] = 0;   

48.       RightNode[i] = -1;   

49.       LeftNode[i] = -1;   

50.     }   
51.   }   
52.   

53.   // ----------------------------------------------------   

54.   // 建立二叉树   

55.   // ----------------------------------------------------   

56.   public void Create(int Data) {   

57.     int i; // 循环计数变量   

58.     int Level = 0; // 树的阶层数   

59.     int Position = 0;   

60.   

61.     for (i = 0; TreeData[i] != 0; i++)   

62.       ;   
63.   
64.     TreeData[i] = Data;   

65.     while (true) // 寻找节点位置   

66.     {   

67.       // 判断是左子树或是右子树   

68.       if (Data > TreeData[Level]) {   

69.         // 右树是否有下一阶层   

70.         if (RightNode[Level] != -1)   

71.           Level = RightNode[Level];   

72.         else {   

73.           Position = -1; // 设定为右树   

74.           break;   

75.         }   

76.       } else {   

77.         // 左树是否有下一阶层   

78.         if (LeftNode[Level] != -1)   

79.           Level = LeftNode[Level];   

80.         else {   

81.           Position = 1; // 设定为左树   

82.           break;   

83.         }   
84.       }   
85.     }   
86.   

87.     if (Position == 1) // 建立节点的左右连结   

88.       LeftNode[Level] = i; // 连结左子树   

89.     else  

90.       RightNode[Level] = i; // 连结右子树   

91.   }   
92.   

93.   // ---------------------------------------------------------   

94.   // 二叉树中序遍历   

95.   // ---------------------------------------------------------   

96.   public static void InOrder(int Pointer) {   

97.     if (Pointer != -1) // 遍历的终止条件   

98.     {   

99.       InOrder(LeftNode[Pointer]); // 处理左子树   

100.       // 处理打印节点内容   

101.       System.out.print(" " + TreeData[Pointer] + " ");   

102.       InOrder(RightNode[Pointer]); // 处理右子树   

103.     }   
104.   }   
105. }  

运行结果
排序前 : 10 32 1 9 5 7 12 2 4 3
排序后 : 1 2 3 4 5 7 9 10 12 32

JAVA排序算法实现代码-希尔Shell排序

1. /**  
2.  * JAVA排序算法实现代码-希尔Shell排序。  
3.  *   
4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
5.  *   
6.  */  

7. public class Test {   

8.   public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   

9.   

10.   public static void main(String args[]) {   

11.     int i; // 循环计数变量   

12.     int Index = a.length;// 数据索引变量   

13.   

14.     System.out.print("排序前: ");   

15.     for (i = 0; i < Index - 1; i++)   

16.       System.out.printf("%3s ", a[i]);   

17.     System.out.println("");   

18.   

19.     ShellSort(Index - 1); // 选择排序   

20.     // 排序后结果   

21.     System.out.print("排序后: ");   

22.     for (i = 0; i < Index - 1; i++)   

23.       System.out.printf("%3s ", a[i]);   

24.     System.out.println("");   

25.   }   
26.   

27.   public static void ShellSort(int Index) {   

28.     int i, j, k; // 循环计数变量   

29.     int Temp; // 暂存变量   

30.     boolean Change; // 数据是否改变   

31.     int DataLength; // 分割集合的间隔长度   

32.     int Pointer; // 进行处理的位置   

33.   

34.     DataLength = (int) Index / 2; // 初始集合间隔长度   

35.   

36.     while (DataLength != 0) // 数列仍可进行分割   

37.     {   

38.       // 对各个集合进行处理   

39.       for (j = DataLength; j < Index; j++) {   

40.         Change = false;   

41.         Temp = a[j]; // 暂存Data[j]的值,待交换值时用   

42.         Pointer = j - DataLength; // 计算进行处理的位置   

43.   

44.         // 进行集合内数值的比较与交换值   

45.         while (Temp < a[Pointer] && Pointer >= 0 && Pointer <= Index) {   

46.           a[Pointer + DataLength] = a[Pointer];   

47.           // 计算下一个欲进行处理的位置   

48.           Pointer = Pointer - DataLength;   

49.           Change = true;   

50.           if (Pointer < 0 || Pointer > Index)   

51.             break;   

52.         }   

53.         // 与最后的数值交换   

54.         a[Pointer + DataLength] = Temp;   
55.   

56.         if (Change) {   

57.           // 打印目前排序结果   

58.           System.out.print("排序中: ");   

59.           for (k = 0; k < Index; k++)   

60.             System.out.printf("%3s ", a[k]);   

61.           System.out.println("");   

62.         }   
63.       }   

64.       DataLength = DataLength / 2; // 计算下次分割的间隔长度   

65.     }   
66.   }   
67. }  

运行结果
排序前: 10 32 1 9 5 7 12 0 4
排序中: 5 32 1 9 10 7 12 0 4
排序中: 5 7 1 9 10 32 12 0 4
排序中: 5 7 1 0 10 32 12 9 4
排序中: 4 7 1 0 5 32 12 9 10
排序中: 1 7 4 0 5 32 12 9 10
排序中: 1 0 4 7 5 32 12 9 10
排序中: 1 0 4 7 5 9 12 32 10
排序中: 1 0 4 7 5 9 10 32 12
排序中: 0 1 4 7 5 9 10 32 12
排序中: 0 1 4 5 7 9 10 32 12
排序中: 0 1 4 5 7 9 10 12 32
排序后: 0 1 4 5 7 9 10 12 32

JAVA排序算法实现代码-插入排序

1. /**  
2.  * JAVA排序算法实现代码-插入排序。  
3.  *   
4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
5.  *   
6.  */  

7. public class Test {   

8.   public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   

9.   

10.   public static void main(String args[]) {   

11.     int i; // 循环计数变量   

12.     int Index = a.length;// 数据索引变量   

13.   

14.     System.out.print("排序前: ");   

15.     for (i = 0; i < Index - 1; i++)   

16.       System.out.print(" " + a[i] + " ");   

17.     System.out.println("");   

18.   

19.     InsertSort(Index - 1); // 选择排序   

20.     // 排序后结果   

21.     System.out.print("排序后: ");   

22.     for (i = 0; i < Index - 1; i++)   

23.       System.out.print(" " + a[i] + " ");   

24.     System.out.println("");   

25.   }   
26.   

27.   public static void InsertSort(int Index) {   

28.     int i, j, k; // 循环计数变量   

29.     int InsertNode; // 欲插入数据变量   

30.   

31.     for (i = 1; i < Index; i++) // 依序插入数值   

32.     {   

33.       InsertNode = a[i]; // 设定欲插入的数值   

34.       j = i - 1; // 欲插入数组的开始位置   

35.       // 找适当的插入位置   

36.       while (j >= 0 && InsertNode < a[j]) {   

37.         a[j + 1] = a[j];   

38.         j--;   
39.       }   

40.       a[j + 1] = InsertNode; // 将数值插入   

41.       // 打印目前排序结果   

42.       System.out.print("排序中: ");   

43.       for (k = 0; k < Index; k++)   

44.         System.out.print(" " + a[k] + " ");   

45.       System.out.println("");   

46.     }   
47.   }   
48. }  

运行结果
排序前: 10 32 1 9 5 7 12 0 4
排序中: 10 32 1 9 5 7 12 0 4
排序中: 1 10 32 9 5 7 12 0 4
排序中: 1 9 10 32 5 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序中: 1 5 7 9 10 32 12 0 4
排序中: 1 5 7 9 10 12 32 0 4
排序中: 0 1 5 7 9 10 12 32 4
排序中: 0 1 4 5 7 9 10 12 32
排序后: 0 1 4 5 7 9 10 12 32

排序算法总结

排序法

平均时间

最差情形

稳定度

额外空间

备注

冒泡

O(n2)

O(n2)

稳定

O(1)

n小时较好

交换

O(n2)

O(n2)

不稳定

O(1)

n小时较好

选择

O(n2)

O(n2)

不稳定

O(1)

n小时较好

插入

O(n2)

O(n2)

稳定

O(1)

大部分已排序时较好

基数

O(logRB)

O(logRB)

稳定

O(n)

B是真数(0-9)，R是基数(个十百)

Shell

O(nlogn)

O(ns) 1<s<2

不稳定

O(1)

s是所选分组

快速

O(nlogn)

O(n2)

不稳定

O(nlogn)

n大时较好

归并

O(nlogn)

O(nlogn)

稳定

O(1)

n大时较好

堆

O(nlogn)

O(nlogn)

不稳定

O(1)

n大时较好

以上是 java排序算法实现代码 的全部内容， 来源链接： utcz.com/z/392181.html