java顺序表 排序_Java: 实现顺序表和单链表的快速排序

快速排序

快速排序原理

快速排序(Quick Sort)的基本思想是，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可对这两部分记录继续进行排序，以达到整个序列有序的目的。

主程序

package Sort;

public class QuickSort {

private void Qsort(int[] list, int low, int high){

int privot;

if(low < high) {

print(list);

/*算出枢轴值privot*/

privot = Partition(list, low, high);

/*对低子表递归排序*/

Qsort(list, low, privot-1);

/*对高子表递归排序*/

Qsort(list, privot+1, high);

}

}

private int Partition(int[] list, int low, int high){

/*用表的第一个记录做枢轴记录*/

int privotkey = list[low];

while (low < high){

while (low < high && list[high] > privotkey)

high--;

/*将比枢轴记录小的记录交换到低端*/

swap(list, low, high);

while (low < high && list[low] < privotkey)

low++;

/*将比枢轴记录大的记录交换到高端*/

swap(list, low, high);

}

/*返回枢轴所在的位置*/

return low;

}

private void swap(int [] list,int j, int i){

int temp;

temp = list[i];

list[i] = list[j];

list[j] = temp;

}

private void print(int[] data) {

System.out.println("当前list数组的值：");

for (int i = 0; i < data.length; i++) {

System.out.print(data[i] + "\t");

}

System.out.println();

}

public static void main(String[] args) {

int[] list = {50,40,80,30,60,70,10,90,20};

QuickSort qs = new QuickSort();

qs.Qsort(list, 0, list.length-1);

qs.print(list);

}

}

Qsort()分析

private void Qsort(int[] list, int low, int high){

int privot;

if(low < high) {

print(list);

/*算出枢轴值privot*/

privot = Partition(list, low, high);

/*对低子表递归排序*/

Qsort(list, low, privot-1);

/*对高子表递归排序*/

Qsort(list, privot+1, high);

}

}

Partition()分析

private int Partition(int[] list, int low, int high){

/*用表的第一个记录做枢轴记录*/

int privotkey = list[low];

while (low < high){

while (low < high && list[high] > privotkey)

high--;

/*将比枢轴记录小的记录交换到低端*/

swap(list, low, high);

while (low < high && list[low] < privotkey)

low++;

/*将比枢轴记录大的记录交换到高端*/

swap(list, low, high);

}

/*返回枢轴所在的位置*/

return low;

}

输出结果

当前list数组的值：

504080306070109020

当前list数组的值：

204010305070609080

当前list数组的值：

102040305070609080

当前list数组的值：

102030405070609080

当前list数组的值：

102030405060709080

当前list数组的值：

102030405060708090

时间复杂度分析

最优情况下，快速排序算法的时间复杂度为O(nlogn)，空间复杂度也为O(nlogn)

单链表快速排序实现

/**

* Definition for singly-linked list.

* public class ListNode {

* int val;

* ListNode next;

* ListNode(int x) { val = x; }

* }

*/

public class Solution {

public ListNode sortList(ListNode head) {

if(head == null || head.next == null) return head;

ListNode left = new ListNode(0), leftHead = left;

ListNode right = new ListNode(0), rightHead = right;

ListNode mid = new ListNode(0), midHead = mid;

int val = head.val;

while(head != null) {

if(head.val < val) {

left.next = head;

left = head;

} else if(head.val > val) {

right.next = head;

right = head;

} else {

mid.next = head;

mid = head;

}

head = head.next;

}

left.next = null;

right.next = null;

mid.next = null;

return merge(sortList(leftHead.next), midHead.next, sortList(rightHead.next));

}

public ListNode merge(ListNode left, ListNode mid, ListNode right) {

ListNode leftTail = getTail(left);

ListNode midTail = getTail(mid);

midTail.next = right;

if(leftTail != null) {

leftTail.next = mid;

return left;

} else {

return mid;

}

}

public ListNode getTail(ListNode head) {

if(head == null) return head;

while(head.next != null) {

head = head.next;

}

return head;

}

}