数据结构：排序

数据结构排序算法（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中列表一样的效果。