数据结构：排序
数据结构排序算法（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++){冒泡排序java代码详解
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中列表⼀样的效果。