数据结构排序算法(Java和Python版本):

 

1、简单选择排序(属于选择排序):

  从数列第一个索引开始遍历:

  第一步:拿第一个索引的数和后面n-1个数相比,找出最小的数放在第一个索引上,这样就确定了最小的数了;

  第二步:拿第二个索引的数和后面n-1个数相比,找出次小的数放在第二个索引上,这样就确定了次小的数了;

  ...

  依次类推,直到遍历结束。

Python代码如下:

def select_sort(li):
    for i in range(len(li)):
        for j in range(i, len(li)):
            if li[i] > li[j]:
                temp = li[i]
                li[i] = li[j]
                li[j] = temp
    
    return li 

Java代码如下:

public void selectSort(int[] array){
        for(int i = 0; i < array.length; i++){
            for(int j = i; j < array.length; j++){
                if(array[i] > array[j]){
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
}

 

2、冒泡排序:

  从索引0开始遍历到索引n-2:

  第一步:从索引0遍历到索引n-2,每次比较后一个索引值与当前索引值的大小,将大的置于后面,小的置于前面,这样遍历完之后,最后一个索引的值即为最大值;

  第二步:从索引0遍历到索引n-3,每次比较后一个索引值与当前索引值的大小,将大的置于后面,小的置于前面,这样遍历完之后,n-2索引的值即为次大值;

  ...

  依次类推,直到遍历结束,数列也编程从小打到排列了。

Python代码如下:

def bubble_sort(li):
    for i in range(len(li)):
        for j in range(len(li) - 1 - i):
            if li[j] > li[j + 1]:
                temp = li[j]
                li[j] = li[j + 1]
                li[j + 1] = li[j]
    return li

Java代码如下:

public void bubbleSort(int[] array){
        for(int i = 0; i < array.length; i++){
            for(int j = 0; j < (array.length - 1 - i); j++){
                if(array[j] > array[j + 1]){
                    int temp = array[j];
                    array[j] = array[j +1];
                    array[j + 1] = temp;
                }
            }
        }
}

 

3、直接插入排序(属于插入排序):

  直接插入排序的思想是将一个数(记作哨兵)插入到一个已经排好序的数列当中。

  对于一个数列,从第2个数开始遍历:

  第一步:将第一个数字当做初始已排序好的数列,将第二个数字当做哨兵,与初始数列的值比较,插入到其中;

  第二步:将第三个数字当做哨兵,与排序好的数列(两个数)中的每个值进行比较(从右到左比),插入到其中;

  第三步:将第四个数字当做哨兵,与排序号的数列(三个数)中的每个值进行比较(从右到左比),插入到其中;

  ...

  依次类推,直到数列的所有数字都遍历。

Python代码如下:

def insert_sort(li):
    for i in range(1, len(li)):
        key = li[i]
        j = i - 1
        while j >= 0:
            if li[j] > key:  # 如果当前索引值比哨兵值大,则将当前索引值保存到temp,然后将当前索引值改为哨兵值,将当前索引的后一个索引值改为temp
                temp = li[j]
                li[j] = key
                li[j + 1] = temp
            j -= 1
    return li

Java代码如下:

public void insertSort(int[] array){
        for(int i = 1; i < array.length; i++){
            int key = array[i];
            int j = i - 1;
            while(j >= 0){
                if(array[j] > key){
                    int temp = array[j];
                    array[j] = key;
                    array[j + 1] = temp;
                }
                j--;
            }
        }
}

 

4、归并排序(递归过程):

  每一步将数据两两合并为一个有序数列。

  用例子来说明:比如一个数列为[45, 38, 65, 97, 76, 13, 27, 49]。

  第一步:将45和38合并没一个有序数列为[38, 45],将65和97合并为一个有序数列为[65, 97],依次类推,第一步结果为:[[38, 45], [65, 97], [13, 76], [27, 49]];

  第二步:将[38, 45]和[65, 97]合并为[38, 45, 65, 97],将[13, 76]和[27, 49]合并为[13, 27, 49, 76],第二步结果为:[[38, 45, 65, 97], [13, 27, 49, 76]];

  第三步:将[38, 45, 65, 97]和[13, 27, 49, 76]合并为[13, 27, 38, 45, 49, 65, 76, 97],结束。

Python代码如下:

 

# 该函数是将两个有序数列合并为一个有序数列
# left和right分贝代表两个有序数列
# 举个例子来说明函数merge,[13, 76]和[27, 49]。
# 设置i和j分别遍历[13, 76]和[27, 49],因为本身已经有序,因此先比较最小的两个13和27,将其中较小的13追加到一个空列表null_li中,然后将i增1,继续比较,依次类推,等while循环结束,
# 则查看i和j,看谁先遍历完了,对于另一个没遍历完的,将其剩余元素追加到null_li中。
def merge(left, right): null_li
= [] i = j = 0 while i < len(left) and j < len(right): if left[i] < right[j] null_li.append(left[i]) i += 1 else: null_li.append(right[j]) j += 1 if i == len(left): for h in right[j: ]: null_li.append(h) else: for t in left[i: ]: null_li.append(t) return null_li # 该函数即为归并排序的代码
# 首先判断一个数列长度是否小于1,如果是,则直接返回,如果不是,则将数列分为两半,然后对这两个数列再进行归并排序,最后返回这两个数列的归并结果。 def merge_sort(li):
if len(li) <= 1: reurn li middle = len(li) / 2 left = merge_sort(li[: middle]) right = merge_sort(li[middle: ]) return merge(left, right)

 

Java代码如下:

public static int[] merge(int[] left, int[] right){
        int[] nullArray = new int[left.length + right.length];
        int k = 0;
        int i = 0, j = 0;
        while(i < left.length && j < right.length){
            if(left[i] < right[j]){
                nullArray[k] = left[i];
                i++;
                k++;
            }else{
                nullArray[k] = right[j];
                j++;
                k++;
            }
        }
        if(i == left.length){
            for(int t = j; t < right.length; t++){
                nullArray[k] = right[t];
                k++;
            }
        }else{
            for(int t = i; t < left.length; t++){
                nullArray[k] = left[t];
                k++;
            }
        }
        return nullArray;
}
    
    public static int[] mergeSort(int[] array){
        if(array.length <= 1){
            return array;
        }
        
        int middle = array.length / 2;
        int[] left = new int[middle];
        int[] right = new int[array.length - middle];
        for(int i = 0; i < middle; i++){  //将array中索引0到索引middle-1的值赋给数组left
            left[i] = array[i];
        }
        int j = 0; //将array中索引middle到索引length-1的值赋给数组right
        for(int i = middle; i < array.length; i++){
            right[j] = array[i];
            j++;
        }
        int[] left2 = mergeSort(left);
        int[] right2 = mergeSort(right);
        
        return merge(left2, right2);
}

 

 

 

 

注意:在Python中我可以直接用列表来追加元素,而不用控制列表的长度,它会自动根据增加长度;但是对于Java来说,使用数组就麻烦了不少,使用数组必须要控制数组长度,而且对数组中元素进行赋值也需要一个for循环来做。但是使用Java中的集合类ArrayList可以达到和Python中列表一样的效果。