发表于

简单选择排序

简单的排序处理流程
(1)从待排序序列中，找到关键字最小的元素;
(2)如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换;
(3)从余下的N-1个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void selectionSort(int[] list){
    //需要遍历获得最小值得次数
    //注意一点，当排序N个数，经历N-1次遍历，排序完成
    for( int i=0; i<list.length; i++){
        int temp = 0;
        int index = i; // 用来保存最小值的索引
        for( int j=i+1; j<list.length; j++){
            if(list[index]>list[j]){
                index = j;
            }
        }
        temp = list[index];
        list[index] = list[i];
        list[i] = temp;
    }
    return list;
}

堆排序

二叉堆是完全二叉树或者是近似完全二叉树。
二叉堆满足两个特性:
1、父节点的键值总是大于或等于(小于或等于)任何一个子节点的键值。
2、每个结点的左子树和右子树

1
2
3
4
5
6
7
8
9
10
11
12
def heap_adjust(data, s, m):
    if 2*s > m:
        return
    temp = s - 1
    if data[2*s-1] > data[temp]:
        temp = 2*s - 1
    
    if 2*s <= m-1 and data[2*s] > data[temp]:
        temp = 2*s
    if temp<> s-1:

发表于

排序算法有内部排序和外部排序， 内部排序是数据记录在内存中进行排序， 而外部排序是因排序的数据很大， 一次不能容纳全部排序记录， 在排序过程中要访问外存。本文的八大排序是内部排序。

1、直接插入排序

使用java实现：

1
2
3
4
5
6
7
8
9
10
11
12
public static void insertsort(int arr[]){
    for(int i = 1; i<arr.length; i++){
        if(arr[i] < arr[i-1]){
            int temp = arr[i];
            int j;
            for(j = i-1; j>00&&arr[j]>temp; j--){
                arr[j+1] = arr[j];
            }
            arr[j+1] = temp;
        }
    }
}

使用python实现

1
2
3
4
5
6
7
8
9
10
def insertsort(arr):
    for i in range(len(l)):
        temp = arr[i]
        j = i
        while j>0 and temp<arr[j-1]:
            arr[j] = arr[j-1]
        
        arr[j] = temp
    return arr

使用javascript实现

1
2
3
4
5
6
7
8
9
10
11
12
13
function insertsort(arr){
    for(var i=1; i<arr.length; i++){
        var temp = arr[i];
        var j;
        for(j = i-1; j>=0&&arr[j]>temp; j--){
            arr[j+1] = arr[j];
        }
        arr[j] = temp;
    }
    return arr;
}

2、希尔排序

希尔(shell)排序又称为缩小增量排序，他是一种插入排序。是直接插入排序算法的一种威力加强版。该方法因DL.Shell于1959年提出而得名。
希尔排序的基本思想是：
1、把记录按步长gap分组，对于每组记录采用直接插入排序方法进行排序。
2、随着步长逐渐减小，所分成的组包含的记录越来越多，当步长的值减小到1时，整个数据合成为一组。构成一组有序记录完成排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void shellSort(int[] list){
    int gap = list.length/2;
    while(1<=gap){
        for(int i = gap; i<list.length; i++){
            int temp = a[i];  
            int k = i - gap;  
            while (k >= 0 && a[k] > temp)  
            {  
                a[k + gap] = a[k];  
                k -= gap;  
            }  
            a[k + gap] = temp;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
# coding:utf-8
def shellSort(nums):
#设定步长
    step = len(nums)/2
    while step>0:
        for i in range(step, len(nums)):
            while i>=step and nums[i-step] > nums[i]:
                nums[i],nums[i-step] = nums[i-step],nums[i]
                i -= step
        step = step/2
    return nums
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function shellSort(nums){
    
    for(var step=nums.lengh/2;step>0;step=step/2){
        for(var i=step;i<nums.length;i++){
            var temp = nums[i];
            int k = i - gap;
            while(k>=0&&nums[k]>temp){
                
                nums[k] = nums[k-step];
                k -=step;
            }
            a[k+gap] = temp;
        }
    } 
}

发表于

测试图片

测试视频


测试代码

1
2
3
4
a = range(1,11)
b = range(1,10)
c =  sum([item for item in a if item in b])
print c

测试音频

发表于

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment