数据结构学习（冒泡、选择、插入、快速排.....

#coding=utf-8


‘‘‘

数据结构排序

‘‘‘

#函数冒泡排序

#   参数alist：被排序的列表

def bubbleSort(alist):

    for num in range(len(alist)-1,0,-1):

        for i in range(num):

            if alist[i] < alist[i+1]:

                #进行当前位置和下一个位置的交换

                alist[i] = alist[i]^alist[i+1]

                alist[i+1] = alist[i]^alist[i+1]

                alist[i] = alist[i]^alist[i+1]

    return alist
#函数选择排序

#   参数alist：被排序的列表

def selectSort(alist):

    for num in range(len(alist)-1,0,-1):

        positionMax = 0

        for index in range(1,num+1):

            if alist[positionMax] < alist[index]:

                positionMax = index
# temp = alist[num]

        # alist[num] = alist[positionMax]

        # alist[positionMax] =temp
alist[num] = alist[num]^alist[positionMax]

        alist[positionMax] = alist[num]^alist[positionMax]

        alist[num] = alist[num]^alist[positionMax]

        print alist[num]

    return alist
#函数插入排序

#   参数alist：被排序的列表

def insertSort(alist):

    for index in range(1,len(alist)):

        temp = alist[index]

        protion = index
while alist[protion-1] > temp and protion > 0:

            alist[protion] = alist[protion-1]

            protion = protion-1
alist[protion] = temp

    return alist
number=[54,26,93,17,77,31,44,55,21]
#快速排序

#    参数alist：被排序的列表

#    参数low：左侧起始位置

#    参数hegh：右侧终止位置

def quickSort(alist,low,hegh):

    if low < hegh:

        pos = findpos(alist,low,hegh)
quickSort(alist, low, pos-1)

        quickSort(alist, pos+1, hegh)
return alist
#快排中查找中间节点

#    参数alist：被产讯的列表

#    参数low：左侧起始位置

#    参数hegh：右侧终止位置

def findpos(alist,left,right):

    temp = alist[left]
while left < right:

        while left < right and alist[right] >= temp:

            right -= 1

        alist[left] = alist[right]
while left < right and alist[left] <= temp:

            left += 1

        alist[right] = alist[left]
alist[right] = temp
return right
if __name__ == "__main__":
# #测试冒泡排序：

    # num = bubbleSort(number)

    # print num
# #调用选择排序

    # num = selectSort(number)

    # print num
#调入插入排序

    num = insertSort(number)

    print num

# #快速排序 # num = quickSort(number, 0, len(number)-1) # print num

原文地址：http://blog.51cto.com/13587708/2147667

时间： 2024-08-01 05:08:31

数据结构学习（冒泡、选择、插入、快速排.....的相关文章

python 数据结构与算法之排序(冒泡,选择,插入)

目录数据结构与算法之排序(冒泡,选择,插入) 为什么学习数据结构与算法: 数据结构与算法: 算法: 数据结构冒泡排序法选择排序法插入排序法数据结构与算法之排序(冒泡,选择,插入) 为什么学习数据结构与算法: 计算机重要的几门课: 1.数据结构和算法 2.网络 3.操作系统 4.计算组成原理数据结构与算法: 算法: 衡量算法的标准: 时间复杂度:就是程序代码执行的大概次数小结: 时间复杂度是用来估计算法运行时间的一个式子(单位) 一般来说,时间复杂度高的算法比复杂度低的算法慢常见的

冒泡选择插入快速，四种最基础排序算法实现

<?php /** * Created by PhpStorm. * User: chm * Date: 2016/4/1 * Time: 19:35 */ //插入排序特点是一边是排好顺序的,另一边一个一个和顺序的数据对比,每次对比插入一个 function charu($arr) { $len = count($arr); //先给出一个原数组 echo "原数组为:"; for($y = 0;$y < $len;$y++){ echo $arr[$y]; } echo

java中各种经典排序（冒泡选择插入希尔等）

1 import java.util.Arrays; 2 3 public class ArraySort { 4 public static void main(String[] args) { 5 int[] arr = { 12, 23, 14, 5, 64, 35, 42 }; 6 System.out.println("排序前:"); 7 System.out.println(Arrays.toString(arr)); 8 // bubbleSort(arr); 9 //

冒泡选择插入希尔堆归并快速排序算法

排序相关概念排序:对一序列对象根据某个关键字进行排序: 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面: 不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面: 内排序:所有排序操作都在内存中完成: 外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行: 排序耗时的操作:比较.移动: 排序分类: (1)交换类:冒泡排序.快速排序:此类的特点是通过不断的比较和交换进行排序: (2)插入类:简单插入排序.希尔排序:此类的特点是通过插入的

数据结构学习之选择排序

1.直接选择排序: 先上图: 说实话,直接选择排序最类似于人的本能思想,比如把大小不一的玩具让三岁小毛孩对大小排个序, 那小孩首先会在这么多玩具中找到最小的放在第一位,然后找到次小的放在第二位,以此类推...... 第一步: 我们拿80作为参照物(base),在80后面找到一个最小数20,然后将80跟20交换. 第二步: 第一位数已经是最小数字了,然后我们推进一步在30后面找一位最小数,发现自己最小,不用交换. 第三步:........ 程序源码为: 1 package com.swust.

冒泡选择插入希尔归并快速排序等python实现

def bubble_sort(a_list): for pass_num in range(len(a_list) - 1, 0, -1): for i in range(pass_num): if a_list[i] > a_list[i + 1]: a_list[i], a_list[i + 1] = a_list[i + 1], a_list[i] def short_bubble_sort(a_list): exchanges = True pass_num = len(a_list)

基本排序-冒泡/选择/插入(python)

# -*- coding: utf-8 -*- import random def bubble_sort(seq): n = len(seq) for i in range(n-1): print(seq) for j in range(n-1-i): if seq[j] > seq[j+1]: seq[j], seq[j+1] = seq[j+1], seq[j] print(seq) def test_bubble_sort(): seq = list(range(10)) random.

排序算法(一)3种简单排序(选择，冒泡，插入)

排序是数据处理中十分常见且核心的操作,虽说实际项目开发中很小几率会需要我们手动实现,毕竟每种语言的类库中都有n多种关于排序算法的实现.但是了解这些精妙的思想对我们还是大有裨益的.本文简单温习下最基础的三类算法:选择,冒泡,插入. 先定义个交换数组元素的函数,供排序时调用 /** * 交换数组元素 * @param arr * @param a * @param b */ public static void swap(int []arr,int a,int b){ arr[a] = arr[a]

排序算法-冒泡——插入——快排

冒泡排序,往两个方向泡,一个往小泡,一个网大泡 #include<stdio.h> #include<stdlib.h> #include<time.h> void bubble_sort(int *a,int n){ int temp; for(int i=0;i<n;i++) for(int j=0;j<n-i-1;j++){ if(a[j]>a[j+1]){ temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } } v

排序算法-冒泡、插入、归并、希尔、快速、选择--代码总结

冒泡排序代码: #include <iostream> #include <string> using namespace std; template<class ItemType> void bubbleSort(ItemType theArray[], int n) { bool sorted = false; // False when swaps occur int pass = 1; while (!sorted && (pass < n