2. 程式人生 > >資料結構和算法系列6 七大排序之直接選擇排序和堆排序

資料結構和算法系列6 七大排序之直接選擇排序和堆排序

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

上一篇我們總結了交換排序的氣泡排序和快速排序。那麼這一篇我們要總結的是選擇排序，選擇排序分為直接選擇排序和堆排序，我們主要分以下幾點進行總結。

1，直接選擇排序及演算法實現

2，堆排序及演算法實現

1，直接選擇排序及演算法實現

直接選擇排序(Straight Select Sort)是一種簡單的排序方法，它的基本思想是：通過n-i次關鍵字之間的比較，從n-i+1個記錄中選出關鍵字最小的記錄，並和第i(1<=i<=n)個記錄交換位置。

比如，下圖展示了直接選擇排序的過程。

下面是演算法的實現程式碼。

C#版：

複製程式碼 
namespace SelectionSort.CSharp
{
    
 
class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int> { 50, 10, 90, 30, 70, 40, 80, 60, 20 };
            Console.WriteLine("********************直接選擇排序********************");
            Console.WriteLine("排序前：");
            Display(list);

            Console.WriteLine(
 
"排序後：");
            SelectionSort(list);
            Display(list);

            Console.ReadKey();
        }

        /// <summary>
        /// 直接選擇排序演算法
        /// </summary>
        /// <returns>排序後的list</returns>
        public static void SelectionSort(List<int> list)
        {
            
 
//要遍歷的次數(遍歷n-1次)
            for (int i = 0; i < list.Count-1 ; i++)
            { 
                //將當前下標定義為最小值下標
                int min = i;

                //遍歷之後的資料
                for (int j = i + 1; j <= list.Count-1; j++)
                {
                    //如果有小於當前最小值的關鍵字，將它的下標賦值給min
                    if (list[min] > list[j]) min = j;
                }

                //若min不等於i，說明找到真正最小值，交換真正最小值與之前假設最小值的位置
                if (i != min) Swap(list,i,min);
            }
        }

        private static void Swap(List<int> list, int i, int min)
        { 
            int temp=list[i];
            list[i]=list[min];
            list[min] = temp;
        }

        /// <summary>
        /// 列印列表元素
        /// </summary>
        /// <param name="list"></param>
        private static void Display(List<int> list)
        {
            Console.WriteLine("\n**********展示結果**********\n");

            if (list != null && list.Count > 0)
            {
                foreach (var item in list)
                {
                    Console.Write("{0} ", item);
                }
            }

            Console.WriteLine("\n**********展示完畢**********\n");
        }
    }
}
複製程式碼

程式執行結果：

ds24

C語言版：

複製程式碼 
/*包含標頭檔案*/
#include "stdio.h"
#include "stdlib.h"   
#include "io.h"
#include "math.h" 
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100

typedef int Status; 
typedef struct
{
    int data[MAXSIZE];
    int length;    
}SeqList;

/*交換
*注意要先宣告方法，然後再呼叫，否則會報錯
*/
void Swap(SeqList *seqList,int i,int min)
{
    int temp;
    temp=seqList->data[i];
    seqList->data[i]=seqList->data[min];
    seqList->data[min]=temp;
}

/*直接選擇排序*/
void SelectionSort(SeqList *seqList)
{
    int i,j,min;

    //要遍歷的次數(遍歷n-1次)
    for (i=0;i<seqList->length-1;i++)
    {
        //將當前下標定義為最小值下標
        min=i;

        //遍歷之後的資料
        for (j=i+1;j<=seqList->length-1;j++)
        {
            //如果有小於當前最小值的關鍵字，將它的下標賦值給min
            if (seqList->data[min]>seqList->data[j]) min=j;
        }

        //若min不等於i，說明找到真正最小值，交換真正最小值與之前假設最小值的位置
        if (i != min) Swap(seqList,i,min);
    }
}

/*列印結果*/
void Display(SeqList *seqList)
{
    int i;
    printf("\n**********展示結果**********\n");

    for (i=0;i<seqList->length;i++)
    {
        printf("%d ",seqList->data[i]);
    }

    printf("\n**********展示完畢**********\n");
}

#define N 9
void main()
{
    int i,j;
    SeqList seqList;

    //定義陣列和初始化SeqList
    int d[N]={50,10,90,30,70,40,80,60,20};

    for (i=0;i<N;i++)
    {
        seqList.data[i]=d[i];
    }
    seqList.length=N;

    printf("***************直接選擇排序***************\n");
    printf("排序前：");
    Display(&seqList);

    SelectionSort(&seqList);
    printf("\n排序後：");
    Display(&seqList);

    getchar();
}
複製程式碼

執行結果同C#版

2，堆排序及演算法實現

堆排序(Heap Sort) 利用堆（一般為大根堆）進行排序的方法。它的基本思想是：將待排序的序列構造成一個大根堆。此時，整個序列的最大值就是堆頂的根結點。將它移走（其實就是將其與堆陣列的末尾元素進行交換，此時末尾元素就是最大值），然後將剩餘的n-1個序列重新構造成一個大根堆，這樣就會得到n個元素中的次大值。如此反覆執行，便能得到一個有序序列了。

堆是具有下列性質的完全二叉樹：每個結點的值都大於或等於其左右孩子結點的值，稱為大根堆；或者每個結點的值都小於或等於其左右孩子結點的值，稱為小根堆，如下圖所示。

下面是其實現程式碼。

C#版：

複製程式碼 
namespace HeapSort.CSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int> { 50, 10, 90, 30, 70, 40, 80, 60, 20 };
            Console.WriteLine("********************堆排序********************");
            Console.WriteLine("排序前：");
            Display(list);

            Console.WriteLine("排序後：");
            HeapSort(list);
            Display(list);

            Console.ReadKey();
        }

        /// <summary>
        /// 堆排序演算法
        /// </summary>
        /// <param name="list"></param>
        public static void HeapSort(List<int> list)
        {
            //將無序堆構造成一個大根堆,大根堆有list.Count/2個父結點
            for (int i = list.Count / 2 - 1; i >= 0;i-- )
            {
                HeadAdjust(list,i,list.Count);
            }

            //逐步將每個最大值的根結點與末尾元素交換，並且再調整其為大根堆
            for (int i = list.Count - 1; i > 0; i--)
            {
                //將堆頂記錄和當前未經排序子序列的最後一個記錄交換位置
                Swap(list,0,i);
                HeadAdjust(list,0,i);
            }
        }

        /// <summary>
        /// 構造大根堆
        /// </summary>
        /// <param name="list"></param>
        /// <param name="parent"></param>
        /// <param name="length"></param>
        public static void HeadAdjust(List<int> list, int parent, int length)
        { 
            //儲存當前父結點
            int temp=list[parent];

            //得到左孩子結點
            int leftChild = 2 * parent + 1;

            while (leftChild < length)
            {
                //如果parent有右孩子，則要判斷左孩子是否小於右孩子
                if (leftChild + 1 < length && list[leftChild] < list[leftChild + 1])
                    leftChild++;

                //父親節點大於子節點，就不用做交換
                if (temp >= list[leftChild])
                    break;

                //將較大子節點的值賦給父親節點
                list[parent] = list[leftChild];

                //然後將子節點做為父親節點，已防止是否破壞根堆時重新構造
                parent = leftChild;

                //找到該父親節點較小的左孩子節點
                leftChild = 2 * parent + 1;
            }
            //最後將temp值賦給較大的子節點，以形成兩值交換
            list[parent] = temp;
        }

        #region Private Method

        private static void Swap(List<int> list, int top, int last)
        {
            int temp = list[top];
            list[top] = list[last];
            list[last] = temp;
        }

        private static void Display(List<int> list)
        {
            Console.WriteLine("\n**********展示結果**********\n");

            if (list != null && list.Count > 0)
            {
                foreach (var item in list)
                {
                    Console.Write("{0} ", item);
                }
            }

            Console.WriteLine("\n**********展示完畢**********\n");
        }

        #endregion
    }
}
複製程式碼

程式執行結果：

ds26

C語言版：

複製程式碼 
/*包含標頭檔案*/
#include "stdio.h"
#include "stdlib.h"   
#include "io.h"
#include "math.h" 
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100

typedef int Status; 
typedef struct
{
    int data[MAXSIZE];
    int length;    
}SeqList;

/*構造大根堆*/
void HeapAdjust(SeqList *seqList,int parent,int length)
{
    int temp,leftChild;

    temp=seqList->data[parent];
    leftChild = 2 * parent + 1;

    while (leftChild < length)
    {
        if (leftChild + 1 < length && seqList->data[leftChild]<seqList->data[leftChild+1]) 
            leftChild++;

        if (temp >= seqList->data[leftChild])
            break;

        seqList->data[parent]=seqList->data[leftChild];

        parent = leftChild;

        leftChild = 2 * parent + 1;
    }
    seqList->data[parent] = temp;
}

/*交換元素*/
void Swap(SeqList *seqList,int top,int last)
{
    int temp=seqList->data[top];
    seqList->data[top]=seqList->data[last];
    seqList->data[last]=temp;
}

/*堆排序演算法*/
void HeapSort(SeqList *seqList)
{
    int i;
    for (i=seqList->length/2-1;i>=0;i--)
    {
        HeapAdjust(seqList,i,seqList->length);
    }

    for (i=seqList->length-1;i>0;i--)
    {
        Swap(seqList,0,i);
        HeapAdjust(seqList,0,i);
    }
}

/*列印結果*/
void Display(SeqList *seqList)
{
    int i;
    printf("\n**********展示結果**********\n");

    for (i=0;i<seqList->length;i++)
    {
        printf("%d ",seqList->data[i]);
    }

    printf("\n**********展示完畢**********\n");
}

#define N 9
void main()
{
    int i,j;
    SeqList seqList;

    //定義陣列和初始化SeqList
    int d[N]={50,10,90,30,70,40,80,60,20};

    for (i=0;i<N;i++)
    {
        seqList.data[i]=d[i];
    }
    seqList.length=N;

    printf("***************堆排序***************\n");
    printf("排序前：");
    Display(&seqList);

    HeapSort(&seqList);
    printf("\n排序後：");
    Display(&seqList);

    getchar();
}
複製程式碼

程式執行結果同上

相關推薦

資料結構和算法系列6 七大排序之直接選擇排序和堆排序

上一篇我們總結了交換排序的氣泡排序和快速排序。那麼這一篇我們要總結的是選擇排序，選擇排序分為直接選擇排序和堆排序，我們主要分以下幾點進行總結。 1，直接選擇排序及演算法實現 2，堆排序及演算法實現 1，直接選擇排序及演算法實現 直接選擇排序(Straight Select Sort)是一種簡單的排序方法，它

資料結構與算法系列6--棧

什麼是棧？ 1.後進者先出，先進者後出，這就是典型的“棧”結構。 2.從棧的操作特性來看，是一種“操作受限”的線性表，只允許在端插入和刪除資料。 什麼時候使用? 當某個資料集合只涉及在某端插入和刪除資料，且滿足後進者先出，先進者後出的操作特性時，我們應該首選棧這種資料結構。

看圖輕鬆理解資料結構與算法系列(Radix樹)

前言 推出一個新系列，《看圖輕鬆理解資料結構和演算法》，主要使用圖片來描述常見的資料結構和演算法，輕鬆閱讀並理解掌握。本系列包括各種堆、各種佇列、各種列表、各種樹、各種圖、各種排序等等幾十篇的樣子。 Radix樹 Radix樹，即基數樹，也稱壓縮字首樹，是一種提供key-value儲存查詢的資料結構。與

資料結構與算法系列 目錄（轉）

轉載地址：https ：//blog.csdn.net/l_215851356/article/details/77659462 最近抽空整理了 “資料結構和演算法” 的相關文章在整理過程中，對於每種資料結構和演算法分別給出 “C”， “C ++” 和 “Java” 的這三種語言

資料結構與算法系列1--簡介

為什麼要學習資料結構和演算法？ 1.直接好處是能夠有寫出效能更優的程式碼 2.演算法，是一種解決問題的思路和方法，有機會應用到生活和事業的其他方面。 3.長期來看，大腦思考能力是個人最重要的核心競爭力，而演算法是為數不多的能夠有效訓練大腦思考能力的途徑之一。 什麼是資料結構？什麼是演

資料結構與算法系列5--連結串列

什麼是連結串列？ 1.和陣列一樣，連結串列也是一種線性表。 2.從記憶體結構來看，連結串列的記憶體結構是不連續的記憶體空間，是將一組零散的記憶體塊串聯起來，從而進行資料儲存的資料結構。 3.連結串列中的每一個記憶體塊被稱為節點Node。節點除了儲存資料外，還需記錄鏈上下一個節點的地址，即

資料結構與算法系列4--陣列

什麼是陣列？ 陣列（Array）是一種線性表資料結構。它用一組連續的記憶體空間，來儲存一組具有相同型別的資料。陣列的一個最大特性就是支援下標隨機訪問陣列元素。 補充： 線性表就是資料排成像一條線一樣的結構。每個線性表上的資料最多隻有前和後兩個方向。其實除了陣列，連結串列、佇列、棧等也是線

資料結構與算法系列7--佇列

什麼是佇列？ 1.先進者先出，這就是典型的“佇列”結構。 2.支援兩個操作：入隊enqueue()，放一個數據到隊尾；出隊dequeue()，從隊頭取一個元素。所以，和棧一樣，佇列也是一種操作受限的線性表。 佇列的應用也非常廣泛，特別是一些具有某些額外特性的佇列，比如迴圈佇列、阻塞佇列、

02-看圖理解資料結構與算法系列(單向連結串列)

單向連結串列 單向連結串列屬於連結串列的一種，也叫單鏈表，單向即是說它的連結方向是單向的，它由若干個節點組成，每個節點都包含下一個節點的指標。 單鏈表特點 建立單鏈表時無需指定連結串列的長度，這個比起陣列結構更加有優勢，而陣列縱使實現成動態陣列也是需要指定一個更大的陣

01-看圖理解資料結構與算法系列(陣列)

  陣列 陣列是最熟悉也是最基礎的一種結構了，有限個相同資料型別的元素按順序排列的集合為陣列。陣列的資料是連續的，有上界下界，在其中的元素都有屬於自己的索引值，即下標，通過這些下標就能定位到陣列值。 根據維度的不同可以將陣列分為一維陣列、二維陣列、三維陣列等等，以此類推。 一維陣列

07-看圖理解資料結構與算法系列(選擇排序)

選擇排序 選擇排序是一種很簡單直觀的排序演算法，主要思想就是每次從待排序的元素中選擇出最大或最小的那個元素，然後將其放至已排序序列的末尾，直到全部待排序序列都排序完畢。 排序要點 初始狀態時，待排序序列為a1,a2,...an，已排序序列為空。 第一趟排序，從

06-看圖理解資料結構與算法系列(AVL樹)

AVL樹 AVL樹，也稱平衡二叉搜尋樹，AVL是其發明者姓名簡寫。AVL樹屬於樹的一種，而且它也是一棵二叉搜尋樹，不同的是他通過一定機制能保證二叉搜尋樹的平衡，平衡的二叉搜尋樹的查詢效率更高。 AVL樹特點 AVL樹是一棵二叉搜尋樹。 AVL樹的左右子節點也是

05-看圖理解資料結構與算法系列(基於陣列的棧)

棧 棧是一種線性儲存結構且運算受限的線性表，它的插入和刪除運算操作被限制在表的一端，該端稱為棧頂，而另外一端則稱為棧底。 棧中的資料以後進先出(Last In First Out 即LIFO)方式進出棧。 棧的實現 棧的實現方式有多種方式，主要是使用不同的結構來儲存棧元素，比如使用陣列、

12-看圖理解資料結構與算法系列(氣泡排序)

氣泡排序 氣泡排序是一種很簡單的排序演算法，主要思想就是不斷走訪待排序序列，每次只比較兩個相鄰元素，如果這倆元素順序不符合要求則對換它們，不斷重複知道沒有相鄰元素需要對換。在不斷走訪比較過程中，越大的元素經過交換會慢慢走到數列頂端，所以看起來它就像氣泡一樣不斷往上冒，於是就叫冒泡。

11-看圖理解資料結構與算法系列(B樹的刪除)

刪除操作 刪除操作比較複雜，主要是因為刪除的項可能在葉子節點上也可能在非葉子節點上，而且刪除後可能導致不符合B樹的規定，這裡暫且稱之為導致B樹不平衡，於是要進行一些合併、左旋、右旋等操作，使之符合B樹的規定（即讓B樹平衡）。另外，如果是刪除非葉子節點項需要先找到中序前驅來替換。 情況

10-看圖理解資料結構與算法系列(B+樹)

B+樹 B+樹是B樹的一種變體，也屬於平衡多路查詢樹，大體結構與B樹相同，包含根節點、內部節點和葉子節點。多用於資料庫和作業系統的檔案系統中，由於B+樹內部節點不儲存資料，所以能在記憶體中存放更多索引，增加快取命中率。另外因為葉子節點相連遍歷操作很方便，而且資料也具有順序性，便於區間查詢。

17-看圖理解資料結構與算法系列(NoSQL儲存-LSM樹)

關於LSM樹 LSM樹，即日誌結構合併樹(Log-Structured Merge-Tree)。其實它並不屬於一個具體的資料結構，它更多是一種資料結構的設計思想。大多NoSQL資料庫核心思想都是基於LSM來做的，只是具體的實現不同。所以本來不打算列入該系列，但是有朋友留言了好幾次讓我講LS

16-看圖理解資料結構與算法系列(快速排序)

快速排序 快速排序由C.A.R.Hoare在1962年提出，是氣泡排序的一種改進。其基本思想為：通過一趟排序將待排序資料分割成獨立的兩部分，其中一部分的所有值都比另一部分的所有值都小，然後再對分割的兩部分分別進行快速排序，整個過程可以遞迴進行，最終所有資料變為有序序列。 排序要點

資料結構與算法系列18--紅黑樹

紅黑樹是平衡二叉查詢樹的一種，上一節我們已經講過二叉查詢樹的定義，那什麼是平衡二叉查詢樹呢？ 什麼是平衡二叉查詢樹 定義： 平衡二叉查詢樹嚴格的定義是：二叉樹中任意一個節點的左右子樹的高度相差不能大於+1。從這個定義來看，的完全二叉樹、滿二叉樹其實都是平衡二叉樹，但是非完全二叉樹也有

資料結構與算法系列17--二叉樹

什麼是二叉樹？ 二叉樹是每個結點最多有兩個子樹的樹結構，它是最常見的一種樹結構。 一些基本概念 根節點：樹的最頂端是節點，如圖中的1節點 父節點：圖中1就是2和3的父節點 子節點：相對的，2和3就是子節點 兄弟節點：在同一父節點下，像2和3就是兄弟節點 葉子節點：沒有子節點的節