直接選擇排序，氣泡排序

阿新 • • 發佈：2019-01-12

排序工具類：

/** 
 * @projectName:Sort 
 * @fileName:SortUtil.java 
 * @packageName:club.younge.sort 
 * @date:2016年8月22日下午11:56:41 
 * @copyright (c) 2016, [email protected] All Rights Reserved. 
 * 
 */  
  
package club.younge.sort;

import java.util.Random;

/** 
 * @className:SortUtil 
 * @function: 排序工具類  
 * @reason:   包含排序演算法，生成隨機陣列，列印結果陣列等 
 * @date:     2016年8月22日 下午11:56:41
 * @author   Younge 
 * @version   
 * @since    JDK 1.8 
 * @see       
 */
public class SortUtil {
	
	public static final void generateRandomData(int[] data){
		Random random = new Random(20l);
		int len = data.length;
		for (int i = 0; i < len; i++) {
			data[i] = Math.abs(random.nextInt()%20);
			System.out.print(" "+ data[i]);
		}
	}
	
	public static final void printData(int[] data){
		int len = data.length;
		for (int i = 0; i < len; i++) {
			System.out.print(" "+ data[i]);
		}
	}
	
	public static final int[] directChooseBigSort(int[] data){
		int len = data.length;
		int temp;
		for (int i = 0; i < len; i++) {
			for (int j = i + 1; j < len; j++) {
				//直接選擇排序， 降序
				if(data[i] < data[j]){
					temp = data[i];
					data[i] = data[j];
					data[j] = temp;
				}
			}
		}
		return data;
	}
	
	public static final int[] directChooseSmallSort(int[] data){
		int len = data.length;
		int temp;
		for (int i = 0; i < len; i++) {
			for (int j = i + 1; j < len; j++) {
				//直接選擇排序， 升序
				if(data[i] > data[j]){
					temp = data[i];
					data[i] = data[j];
					data[j] = temp;
				}
			}
			
		}
		return data;
	}
	
	public static final int[] bubbleSmallSort(int[] data){
		int len = data.length;
		int temp;
		for (int i = 0; i < len; i++) {
			for (int j = 0; j < len - i -1; j++) {
				//最大的往下沉，一個i迴圈排好一個數， 一次排序輕的在上面
				if(data[j] > data[j + 1]){
					temp = data[j];
					data[j] = data[j + 1];
					data[j + 1] = temp;
				}
			}
		}
		return data;
	}
	
	public static final int[] bubbleBigSort(int[] data){
		int len = data.length;
		int temp;
		for (int i = 0; i < len; i++) {
			for (int j = 0; j < len - i -1; j++) {
				//最小的往下沉，一個i迴圈排好一個數， 一次排序重的在上面，反重力
				if(data[j] < data[j + 1]){
					temp = data[j];
					data[j] = data[j + 1];
					data[j + 1] = temp;
				}
			}
		}
		return data;
	}
	
	
}

排序測試類：

/** 
 * @projectName:Sort 
 * @fileName:SortTest.java 
 * @packageName:club.younge.test 
 * @date:2016年8月22日下午11:56:50 
 * @copyright (c) 2016, [email protected] All Rights Reserved. 
 * 
 */  
  
package club.younge.test;

import club.younge.sort.SortUtil;

/** 
 * @className:SortTest 
 * @function: 排序測試  
 * @reason:   
 * @date:     2016年8月22日 下午11:56:50
 * @author   Younge 
 * @version   
 * @since    JDK 1.8 
 * @see       
 */
public class SortTest {

	public static void main(String[] args) {
		int[] data = new int[20];
		
		System.out.print("Switch big sort:");
		System.out.print("\nBefore sort:");
		SortUtil.generateRandomData(data);
		
		data = SortUtil.directChooseBigSort(data);
		System.out.print("\nAfter sort:");
		SortUtil.printData(data);
		
		System.out.print("\n\nSwitch small sort:");
		System.out.print("\nBefore sort:");
		SortUtil.generateRandomData(data);
		data = SortUtil.directChooseSmallSort(data);
		System.out.print("\nAfter sort:");
		SortUtil.printData(data);
		
		System.out.print("\n\nBubble small sort:");
		System.out.print("\nBefore sort:");
		SortUtil.generateRandomData(data);
		data = SortUtil.directChooseSmallSort(data);
		System.out.print("\nAfter sort:");
		SortUtil.printData(data);
		
		System.out.print("\n\nBubble big sort:");
		System.out.print("\nBefore sort:");
		SortUtil.generateRandomData(data);
		data = SortUtil.directChooseSmallSort(data);
		System.out.print("\nAfter sort:");
		SortUtil.printData(data);
	}
}

排序類面向物件重構：

package club.younge.sort;

import java.util.Random;

/** 
 * @className:SortEntity 
 * @function: 排序實體類抽離陣列和陣列長度  
 * @reason:   TODO ADD REASON. 
 * @date:     2016年8月23日 下午1:54:19
 * @author   Younge 
 * @version   
 * @since    JDK 1.8 
 * @see       
 */
public class SortEntity {
	private int[] data;
	private int len;
	public SortEntity(int[] data){
		this.data = data;
		this.len = data.length;
		this.generateRandomData();
	}
	public int[] getData() {
		return data;
	}
	public void setData(int[] data) {
		this.data = data;
	}
	public int getLen() {
		return len;
	}
	public void setLen(int len) {
		this.len = len;
	}
	
	public final void generateRandomData(){
		Random random = new Random(20l);
		for (int i = 0; i < len; i++) {
			data[i] = Math.abs(random.nextInt()%20);
			System.out.print(" "+ data[i]);
		}
	}
	
	public  final void printData(){
		for (int i = 0; i < len; i++) {
			System.out.print(" "+ data[i]);
		}
	}
	
	public void println(String message){
		System.out.println(message);
	}
	
	public final int[] directChooseBigSort(){
		int temp;
		for (int i = 0; i < len; i++) {
			for (int j = i + 1; j < len; j++) {
				//直接選擇排序， 降序
				if(data[i] < data[j]){
					temp = data[i];
					data[i] = data[j];
					data[j] = temp;
				}
			}
		}
		return data;
	}
	
	public final int[] directChooseSmallSort(int[] data){
		int len = data.length;
		int temp;
		for (int i = 0; i < len; i++) {
			for (int j = i + 1; j < len; j++) {
				//直接選擇排序， 升序
				if(data[i] > data[j]){
					temp = data[i];
					data[i] = data[j];
					data[j] = temp;
				}
			}
			
		}
		return data;
	}
	
	public final int[] bubbleSmallSort(int[] data){
		int temp;
		for (int i = 0; i < len; i++) {
			for (int j = 0; j < len - i -1; j++) {
				//最大的往下沉，一個i迴圈排好一個數， 一次排序輕的在上面
				if(data[j] > data[j + 1]){
					temp = data[j];
					data[j] = data[j + 1];
					data[j + 1] = temp;
				}
			}
		}
		return data;
	}
	
	public  final int[] bubbleBigSort(int[] data){
		int temp;
		for (int i = 0; i < len; i++) {
			for (int j = 0; j < len - i -1; j++) {
				//最小的往下沉，一個i迴圈排好一個數， 一次排序重的在上面，反重力
				if(data[j] < data[j + 1]){
					temp = data[j];
					data[j] = data[j + 1];
					data[j + 1] = temp;
				}
			}
		}
		return data;
	}
	
	//非遞迴查詢插入點
	public final int[] secondDivide() {
		int left, right, middle, j;
		int comp;
		for (int i = 1; i < len; i++) {
			left = 0;
			right = i - 1;
			comp = data[i];// 比較點
			// 二分法尋找left插入點
			while (right >= left) {
				middle = (left + right) / 2;
				if (comp >= data[middle]) {
					left = middle + 1;
				} else {
					right = middle - 1;
				}
			}
			// left插入點（含）至比較點前一元素整體後移一個單位
			for (j = i - 1; j >= left; j--) {
				data[j + 1] = data[j];
			}
			// left插入點插入比較點元素
			data[left] = comp;
		}
		return data;

	}
	
	//遞迴查詢插入點
	public int[] secondDivideTraverse() {
		int left, right, j;
		int comp;
		for (int i = 1; i < len; i++) {
			left = 0;
			right = i - 1;
			comp = data[i];// 比較點
			// 二分法尋找left插入點
			left = this.findLeft(left, right, data, comp);
			// left插入點（含）至比較點前一元素整體後移一個單位
			for (j = i - 1; j >= left; j--) {
				data[j + 1] = data[j];
			}
			// left插入點插入比較點元素
			data[left] = comp;
		}
		return data;
	}

	public int findLeft(int left, int right, int[] data, int comp) {
		int m = (left + right) / 2;
		if (left > right) {
			return left;
		} else {
			if (comp >= data[m]) {
				return findLeft(m + 1, right, data, comp);
			} else {
				return findLeft(left, m - 1, data, comp);
			}
		}
	}
	
}

排序將持續更新，Github更新地址：點選開啟連結

排序演算法：選擇排序，直接插入排序，氣泡排序

package com.Algorithm.Search_Sort; import java.util.Arrays; public class Sort { public int array[] = {99,34,76,92,34,17,77,41,40,36,6}; //

C語言實現直接插入排序，氣泡排序，選擇排序，希爾排序，快排

直接插入演算法，每次將未排序的第一個元素插入到前半部分以及排好序的元素中。關鍵是要在已排好的部分進行移位操作。//直接插入排序演算法 void InsertSort(int a[],int n) { for (int i = 1; i < n; i++) {

直接選擇排序，氣泡排序

排序工具類： /** * @projectName:Sort * @fileName:SortUtil.java * @packageName:club.younge.sort * @date:2016年8月22日下午11:56:41 * @copyri

各種排序演算法，一步步更新（一），桶排序，氣泡排序，選擇排序，快速排序

部分方法來自我關注的博主 J_小浩子謝謝 1 桶排序 bucketsort 1 桶排序 #include <stdio.h>//桶排序基本說明 int main(){ int data1[11]={0},tem

python: 選擇排序，氣泡排序，插入排序，快速排序

def selectSort(lyst): n = len(lyst) for i in range(n - 1): minindex = i for j in range(i + 1, n): if lyst[j] <

給一組整數，按照升序排序，使用選擇排序，氣泡排序，插入排序或者任何 O(n2) 的排序演算法

題目描述給一組整數，按照升序排序，使用選擇排序，氣泡排序，插入排序或者任何 O(n2) 的排序演算法。樣例對於陣列 [3, 2, 1, 4, 5], 排序後為：[1, 2, 3, 4, 5]。解答 public class SortNums { pu

排序上篇（選擇排序，氣泡排序，插入排序，希爾排序）

1.選擇排序（1）原理：　在要排序的一組數中，用第一個數與後面的數依次進行判斷，若大於後面的則進行交換；然後依次再用第二個數與後面的數進行交換，如此迴圈到倒數第二個數和最後一個數比較為止。（2）圖解：內層第一次迴圈如下：外層控制迴圈次數：

java幾種排序簡單實現（快速排序，氣泡排序，直接插入排序）

package Test; import com.alibaba.fastjson.JSONObject; public class Test { static int[] arrays = new int[] { 3, 10, 11, 1, 8, 2, 9, 4 }; // index

選擇排序，氣泡排序

選擇排序在一個長度為n的序列中，遍歷整個序列，找出其中最小（大）的元素，將其與未被選擇過的數中的第一個數進行交換，重複以上操作，直到所有數從小（大）到大（小）排列。例如：6 4 7 3 2 8 2 4 7 3 6 8 2 3 7 4 6 8 2 3 47 6 8

選擇排序，氣泡排序，插入排序

1.選擇排序 2.氣泡排序/雙向氣泡排序 3.插入排序 1.選擇排序選擇排序是一種最為直觀的排序方法。每次迴圈從陣列中選擇出一個最小或者最大的元素，按順序重新放入陣列中，直到所有的戴排序元素都排序完成。 public void selectSort(int

常用排序演算法java程式碼實現---快速排序，氣泡排序，選擇排序

快速排序 public class QuickSort { public void qSort(int[] arr,int left,int right) { if(left>right) { return ; } int i = le

python: 選擇排序，氣泡排序，插入排序，快速排序

def selectSort(lyst): n = len(lyst) for i in range(n - 1): minindex = i for j in range(i + 1, n): if l

陣列（選擇排序，氣泡排序）

import java.util.Arrays; import javax.swing.text.StyledEditorKit.ForegroundAction; /* * 排序的兩種簡單演算法：選擇排序，氣泡排序 */ public class SequenceT

各種排序演算法的場景以及c++實現（插入排序，希爾排序，氣泡排序，快速排序，選擇排序，歸併排序）

對現有工作並不是很滿意，所以決定找下一個坑。由工作中遇到排序場景並不多，大都是用氣泡排序，太low，面試又經常問到一些排序演算法方面的東西。剛好讓小學妹郵的資料結構也到了。就把各種排序演算法重新總結一下，以作留存。排序分為內部排序和外部排序，內部排序是在記憶體中排序。外

時間複雜度，插入排序，氣泡排序，選擇排序

理解時間複雜度，插入排序，氣泡排序，選擇排序什麼是時間複雜度就是近似於約等於演算法總的執行的次數；說白了時間複雜度就是近似約等於演算法中常數操作的次數；時間複雜度使用O(n)（可以讀big O n）來表示在一個演算法之中，演算法常數操作次數 * 每個數的常數操作的時間

插入排序，希爾排序，選擇排序，快速排序，氣泡排序，歸併排序

插入排序 1、介紹：簡單插入排序演算法原理：從整個待排序列中選出一個元素插入到已經有序的子序列中去，得到一個有序的、元素加一的子序列，直到整個序列的待插入元素為0，則整個序列全部有序。　　在實際的演算法中

C語言單鏈表的3種排序演算法，插入排序，氣泡排序，選擇排序

//插入排序 stu *view_sort_math(stu *head) { struct student *first; struct student *t; struct student *p; struct student *q; fi

幾種常用的排序演算法（快速排序，希爾排序，堆排序，選擇排序，氣泡排序）

1、歸併排序基本原理：歸併排序也稱合併排序，其演算法思想是將待排序序列分為兩部分，依次對分得的兩個部分再次使用歸併排序，之後再對其進行合併。操作步驟如下。(1)將所要進行的排序序列分為左右兩個部分，如果要進行排序的序列的起始元素下標為first，最後一個元素的

交換排序，氣泡排序，選擇排序

交換排序 for(int i=0;i<length-1;i++) { for(int j=i+1;j<length;j++) { if(arr[

C++DLL匯出類(快排，堆排，插入排序，選擇排序，氣泡排序)

sort.h #ifndef SORT_H #define SORT_H #ifdef DLL_FILE class __declspec(dllexport) sort #else class __declspec(dllimport) so

直接選擇排序， 氣泡排序

相關推薦

直接選擇排序，氣泡排序