剑指offer第二版-排序算法(快排的数组与链表实现)

本系列导航:剑指offer(第二版)java实现导航帖

考查排序算法时大多数情况下被排序数据都是数组形式,但也有可考查链表形式的排序算法。主要差异就是在获取元素上,数组可以在o(1)时间内得到某个下标的元素,而链表只能在o(1)时间内得到下一个节点(如果是双链表也可以得到上一个节点)。明确这一特点之后,就比较容易完成链表的排序算法了。下面以快排为例进行实现。

数组形式:
大部分情况下所写的快排,应该都比较熟了

package chapter2;
import structure.ListNode;
import java.util.LinkedList;
import java.util.List;

/**
 * Created by ryder on 2017/6/27.
 *
 */
public class P79_QuickSortThreeWayImpl {
    //数组快排,时间o(nlogn)(最差n^2),空间o(logn)(最差n),递归造成的栈空间的使用,不稳定
    public static void quickSort(int[] data){
        if(data==null || data.length<=1) return;
        quickSortCore(data,0,data.length-1);
    }
    public static void quickSortCore(int[] data,int start,int end){
        if(end-start<=0)
            return;
        int index = quickSortPartition(data,start,end);
        quickSortCore(data,start,index-1);
        quickSortCore(data,index+1,end);
    }
    public static int quickSortPartition(int[] data,int start,int end){
        //选择第一个值作为基准
        int pivot = data[start];
        int left = start,right = end;
        while(left<right){
            while(left<right && data[right]>=pivot) {
                right--;
            }
            if(left<right)
                data[left] = data[right];
            while(left<right && data[left]<pivot) {
                left++;
            }
            if(left<right)
                data[right] = data[left];
        }
        data[left] = pivot;
        return left;
    }
    public static void testQuickSort(){
        int[] data = {1,5,4,2,3};
        quickSort(data);
        System.out.print("数组快速排序:\t");
        for(int item: data){
            System.out.print(item);
            System.out.print('\t');
        }
        System.out.println();
    }
}

List形式:
百度一下[快排 链表],会发现相当一部分人是使用java.util.List实现的。我也就写了一下。但这个List无法获取下一个节点,而给出的关键方法是set,get,所以在实现上与数组几乎一致,获取值的地方改成get(index),赋值的改成set(index,value)即可。此外,如果测试时传入的是arrayList,依旧是数组快排啊;如果传入的是LinkedList,那么代码中的set,get时间复杂度都是o(n),完成一次分区就要o(n^2)了,还叫什么快排呢。

package chapter2;
import structure.ListNode;
import java.util.LinkedList;
import java.util.List;
/**
 * Created by ryder on 2017/6/27.
 *
 */
public class P79_QuickSortThreeWayImpl {
    //通过List完成快排
    public static void quickSortList(List<Integer> data){
        if(data==null || data.size()<2)
            return;
        quickSortListCore(data,0,data.size()-1);
    }
    public static void quickSortListCore(List<Integer> data,int start,int end){
        if(start>=end)
            return;
        int index = quickSortListPartition(data,start,end);
        quickSortListCore(data,start,index-1);
        quickSortListCore(data,index+1,end);
    }
    public static int quickSortListPartition(List<Integer> data,int start,int end){
        int pivot = data.get(start);
        int left = start,right = end;
        while(left<right){
            while(left<right && data.get(right)>=pivot)
                right--;
            if(left<right)
                data.set(left,data.get(right));
            while(left<right && data.get(left)<pivot)
                left++;
            if(left<right)
                data.set(right,data.get(left));
        }
        data.set(left,pivot);
        return left;
    }
    public static void testQuickSortList(){
        List<Integer> data = new LinkedList<>();
        data.add(1);
        data.add(5);
        data.add(4);
        data.add(2);
        data.add(3);
        quickSortList(data);
        System.out.print("基于List快速排序:\t");
        System.out.println(data);
    }
}

自定义List:
在LeetCode上如果说用单链表实现某一算法,一般都是自定义的一个单链表节点,只能获取节点值value及下一节点next。
在这种纯粹的链表节点下,上述快排是无法达到时间复杂度o(nlogn)的,因为上述算法的分区函数是使用左右指针向中间扫描完成的,而链表获取上一个节点的时间复杂度是o(n),这样完成分区时间就要o(n^2),肯定不能让人满意。
这是就需要修改分区函数。其实快排的分区函数除了左右指针还有另一种实现,使用两个左指针向右移动,一个用于扫描,另一个用于划分小于基准值的区域。而从左向右移动,这种任务链表是可以在o(1)的时间复杂度下完成的。

package structure;
/**
 * Created by ryder on 2017/6/13.
 * 单链表节点
 */
public class ListNode<T> {
    public T val;
    public ListNode<T> next;
    public ListNode(T val){
        this.val = val;
        this.next = null;
    }
    @Override
    public String toString() {
        StringBuilder ret = new StringBuilder();
        ret.append("[");
        for(ListNode cur = this;;cur=cur.next){
            if(cur==null){
                ret.deleteCharAt(ret.lastIndexOf(" "));
                ret.deleteCharAt(ret.lastIndexOf(","));
                break;
            }
            ret.append(cur.val);
            ret.append(", ");
        }
        ret.append("]");
        return ret.toString();
    }
}
package chapter2;
import structure.ListNode;
import java.util.LinkedList;
import java.util.List;

/**
 * Created by ryder on 2017/6/27.
 *
 */
public class P79_QuickSortThreeWayImpl {
    //自定义链表快排
    public static void quickSortList2(ListNode<Integer> data){
        if(data==null || data.next==null)
            return;
        quickSortListCore2(data,null);
    }
    //从start到end排序,不包括end
    public static void quickSortListCore2(ListNode<Integer> start,ListNode<Integer> end){
        if(start==end || start.next==end)
            return;
        ListNode<Integer> index = quickSortList2Partition(start,end);
        quickSortListCore2(start,index);
        quickSortListCore2(index.next,end);
    }
    //两个左起指针向右移动,right从start+1到end(不包括end)向右扫描值,[start,left]存储小于povot的值
    //最终left存储pivot,[start,left)小于pivot,(left+1,end)大于pivot
    public static ListNode<Integer> quickSortList2Partition(ListNode<Integer> start,ListNode<Integer> end){
        int pivot = start.val;
        ListNode<Integer> left = start;
        ListNode<Integer> right = start.next;
        while(right!=end){
            if(right.val>=pivot)
                right = right.next;
            else{
                left.val = right.val;
                left = left.next;
                right.val = left.val;
                right = right.next;
            }
        }
        left.val = pivot;
        return left;
    }
    public static void testQuickSortList2(){
        ListNode<Integer> data = new ListNode<>(1);
        data.next = new ListNode<>(5);
        data.next.next= new ListNode<>(4);
        data.next.next.next= new ListNode<>(2);
        data.next.next.next.next= new ListNode<>(3);
        quickSortList2(data);
        System.out.print("自定义链表快速排序:\t");
        System.out.println(data);
    }
}

整体测试:

package chapter2;

import structure.ListNode;

import java.util.LinkedList;
import java.util.List;

/**
 * Created by ryder on 2017/6/27.
 *
 */
public class P79_QuickSortThreeWayImpl {
    public static void main(String[] args){
        testQuickSort();
        testQuickSortList();
        testQuickSortList2();
    }
}

测试结果:

数组快速排序: 1   2   3   4   5   
基于List快速排序:   [1, 2, 3, 4, 5]
自定义链表快速排序:  [1, 2, 3, 4, 5]
    原文作者:ryderchan
    原文地址: https://www.jianshu.com/p/bbcfb28e3242#comments
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞