算法、结构应用

原创 2007年09月19日 13:40:00

最近又开始找工作,面试、笔试是难免的,这几天多练练手,多写写,很多以前的基础知识略有些手生 :)

int[] iarrary = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34, 75, 33, 47 };

各类算法复杂度:

排序法

平均时间

最差情形

稳定度

额外空间

备注

冒泡

O(n2)

O(n2)

稳定

O(1)

n小时较好

交换

O(n2)

O(n2)

不稳定

O(1)

n小时较好

选择

O(n2)

O(n2)

不稳定

O(1)

n小时较好

插入

O(n2)

O(n2)

稳定

O(1)

大部分已排序时较好

基数

O(logRB)

O(logRB)

稳定

O(n)

B是真数(0-9)R是基数(个十百)

Shell

O(nlogn)

O(ns) 1<2

不稳定

O(1)

s是所选分组

快速

O(nlogn)

O(n2)

不稳定

O(nlogn)

n大时较好

归并

O(nlogn)

O(nlogn)

稳定

O(1)

n大时较好

O(nlogn)

O(nlogn)

不稳定

O(1)

n大时较好



1、冒泡排序(两两比较)

        public static void sort(int[] list)
        {
            int[] newList = new int[list.Length];
            int copyValue = 0;
            for (int i = 0; i < list.Length - 1;i++)
            {
                for (int j = i + 1; j < list.Length;j++)
                {
                    if(list[i] < list[j])
                    {
                        copyValue = list[i];
                        list[i] = list[j];
                        list[j] = copyValue;
                    }
                }
            }
        }

 

2、选择排序(选择最大的索引,交换值)

        public static void sort(int[] list)
        {
            int maxIndex = 0;
            for (int i = 0; i < list.Length - 1; i++)
            {
                maxIndex = i;
                for (int j = i + 1; j < list.Length; j++)
                {
                    if (list[j] > list[maxIndex])
                    {
                        maxIndex = j;
                    }
                }
                int maxValue = list[maxIndex];
                list[maxIndex] = list[i];
                list[i] = maxValue;
            }
        }

3、插入排序(后向前, Check, 插入)
  public static void sort(int[] list)
        {
            for (int i = 1; i < list.Length; i++)
            {
                int originValue = list[i];
                int j = i;
                while ((j > 0) && (list[j - 1] > originValue))
                {
                    list[j] = list[j - 1];
                    --j;
                }
                list[j] = originValue;
            }
        }


4、希尔排序

     public static void sort(int[] list)
        {
            int inc;
            for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;
            for (; inc > 0; inc /= 3)
            {
                for (int i = inc + 1; i <= list.Length; i += inc)
                {
                    int originValue = list[i - 1];
                    int j = i;
                    while ((j > inc) && (list[j - inc - 1] > originValue))
                    {
                        list[j - 1] = list[j - inc - 1];
                        j -= inc;
                    }
                    list[j - 1] = originValue;
                }
            }
        }

 5、快速

/// 快速排序法
         /// </summary>
         /// <param name="list"></param>
         /// <param name="low"></param>
         /// <param name="high"></param>
         public static void Sort(int[] list, int low, int high)
         {
             int pivot;
             int l, r;
             int mid;
             if (high <= low)
                 return;
             else if (high == low + 1)
             {
                 if (list[low] > list[high])
                     Swap(ref list[low], ref list[high]);
                 return;
             }
             mid = (low + high) >> 1;
             pivot = list[mid];
             Swap(ref list[low], ref list[mid]);
             l = low + 1;
             r = high;
             do
             {
                 while (l <= r && list[l] < pivot)
                     l++;
                 while (list[r] >= pivot)
                     r--;
                 if (l < r)
                     Swap(ref list[l], ref list[r]);
             } while (l < r);
             list[low] = list[r];
             list[r] = pivot;
             if (low + 1 < r)
                 Sort(list, low, r - 1);
             if (r + 1 < high)
                 Sort(list, r + 1, high);
         }

6、递归

二、数据结构:
1、为wssmax些的前序、中序、后序遍历的实现

-- 二叉树遍历 --#region -- 二叉树遍历 --

    /**//**//**////创建的是二叉查找树,无重复的结点值
    ///特点:左支树中任何值都小于父结点值,右结点任何值大于父结点值(已排序好的结构)
    public class TreeNode
    {
        private TreeNode leftNode;
        private TreeNode rightNode;
        private int data;

        public TreeNode(int nodeData)
        {
            data = nodeData;
            leftNode = rightNode = null;//没有子树
        }

        public TreeNode LeftNode
        {
            get
            {
                return leftNode;
            }
            set
            {
                leftNode = value;
            }
        }

        public TreeNode RightNode
        {
            get
            {
                return rightNode;
            }
            set
            {
                rightNode = value;
            }
        }

        public int Data
        {
            get
            {
                return data;
            }
            set
            {
                data = value;
            }
        }

        public void Insert(int insertValue)//创建结点
        {
            if (insertValue < data)
            {
                if (leftNode == null)
                    leftNode = new TreeNode(insertValue);
                else
                    leftNode.Insert(insertValue);
            }
            else if (insertValue > data)
            {
                if (rightNode == null)
                    rightNode = new TreeNode(insertValue);
                else
                    rightNode.Insert(insertValue);
            }
        }
    }

    public class Tree
    {
        private TreeNode root;
        public Tree()
        {
            root = null;
        }

        //创建树
        public void InsertNode(int insertValue)
        {
            lock (this)
            {
                if (root == null)
                    root = new TreeNode(insertValue);
                else
                    root.Insert(insertValue);
            }
        }
        //前序遍历
        public void PreorderTraversal()
        {
            lock (this)
            {
                PreorderHelper(root);
            }
        }
        private void PreorderHelper(TreeNode node)//采用了递归
        {
            if (node == null)
                return;
            Console.Write(node.Data + " ");
            PreorderHelper(node.LeftNode);
            PreorderHelper(node.RightNode);
        }
        //中序遍历
        public void InorderTraversal()
        {
            lock (this)
            {
                InorderHelper(root);
            }
        }
        public void InorderHelper(TreeNode node)
        {
            if (node == null)
                return;
            InorderHelper(node.LeftNode);
            Console.Write(node.Data + " ");
            InorderHelper(node.RightNode);
        }
        //后序遍历
        public void PostorderTraversal()
        {
            lock (this)
            {
                PostorderHelper(root);
            }
        }
        public void PostorderHelper(TreeNode node)
        {
            if (node == null)
                return;
            PostorderHelper(node.LeftNode);
            PostorderHelper(node.RightNode);
            Console.Write(node.Data + " ");
        }
    }
        #endregion

2、穷小子—链表处理
-- 链表处理 --#region -- 链表处理 --
namespace List
{
    /**//**//**//// <summary>
    /// Summary description for ListNode.
    /// </summary>
    // 结点类
    public class ListNode
    {
        public ListNode(int NewValue)
        {
            Value = NewValue;
        }
        /**//**//**//// <summary>
        /// 前一个
        /// </summary>
        public ListNode Previous;
        /**//**//**//// <summary>
        /// 后一个
        /// </summary>
        public ListNode Next;
        /**//**//**//// <summary>
        /// 值
        /// </summary>
        public int Value;
    }

    /**//**//**//// <summary>
    /// 链表类
    /// 定义结点之后开始类线性表的操作编程了.在LIST 类中,采用了,Head ,Tail,  Current,三个指针,
    /// 使用Append ,MoveFrist,MovePrevious,MoveNext,MoveLast ,Delete,InsertAscending,InsertUnAscending ,Clear 
    /// 实现移动,添加,删除,升序插入,降序插入,清空链表操作,GetCurrentValue() 方法取得当前的值。
    /// </summary>
    public class Clist
    {
        public Clist()
        {
            //构造函数
            //初始化
            ListCountValue = 0;
            Head = null;
            Tail = null;
        }
        /**//**//**//// <summary>
        /// 头指针
        /// </summary>
        private ListNode Head;
        /**//**//**//// <summary>
        /// 尾指针
        /// </summary>
        private ListNode Tail;
        /**//**//**//// <summary>
        /// 当前指针
        /// </summary>
        private ListNode Current;
        /**//**//**//// <summary>
        /// 链表数据的个数
        /// </summary>
        private int ListCountValue;
        /**//**//**//// <summary>
        /// 尾部添加数据
        /// </summary>
        public void Append(int DataValue)
        {
            ListNode NewNode = new ListNode(DataValue);
            if (IsNull())
            //如果头指针为空
            {
                Head = NewNode;
                Tail = NewNode;
            }
            else
            {
                Tail.Next = NewNode;
                NewNode.Previous = Tail;
                Tail = NewNode;
            }
            Current = NewNode;
            //链表数据个数加一
            ListCountValue += 1;
        }
        /**//**//**//// <summary>
        /// 删除当前的数据
        /// </summary>
        public void Delete()
        {
            //若为空链表
            if (!IsNull())
            {
                //若删除头
                if (IsBof())
                {
                    Head = Current.Next;
                    Current = Head;
                    ListCountValue -= 1;
                    return;
                }
                //若删除尾
                if (IsEof())
                {
                    Tail = Current.Previous;
                    Current = Tail;
                    ListCountValue -= 1;
                    return;
                }
                //若删除中间数据
                Current.Previous.Next = Current.Next;
                Current = Current.Previous;
                ListCountValue -= 1;
                return;
            }
        }
        /**//**//**//// <summary>
        /// 向后移动一个数据
        /// </summary>
        public void MoveNext()
        {
            if (!IsEof()) Current = Current.Next;
        }
        /**//**//**//// <summary>
        /// 向前移动一个数据
        /// </summary>
        public void MovePrevious()
        {
            if (!IsBof()) Current = Current.Previous;
        }
        /**//**//**//// <summary>
        /// 移动到第一个数据
        /// </summary>
        public void MoveFrist()
        {
            Current = Head;
        }
        /**//**//**//// <summary>
        /// 移动到最后一个数据
        /// </summary>
        public void MoveLast()
        {
            Current = Tail;
        }
        /**//**//**//// <summary>
        /// 判断是否为空链表
        /// </summary>
        public bool IsNull()
        {
            if (ListCountValue == 0)
                return true;
            return false;
        }
        /**//**//**//// <summary>
        /// 判断是否为到达尾部
        /// </summary>
        public bool IsEof()
        {
            if (Current == Tail)
                return true;
            return false;
        }
        /**//**//**//// <summary>
        /// 判断是否为到达头部
        /// </summary>
        public bool IsBof()
        {
            if (Current == Head)
                return true;
            return false;
        }
        public int GetCurrentValue()
        {
            return Current.Value;
        }
        /**//**//**//// <summary>
        /// 取得链表的数据个数
        /// </summary>
        public int ListCount
        {
            get
            {
                return ListCountValue;
            }
        }
        /**//**//**//// <summary>
        /// 清空链表
        /// </summary>
        public void Clear()
        {
            MoveFrist();
            while (!IsNull())
            {
                //若不为空链表,从尾部删除
                Delete();
            }
        }
        /**//**//**//// <summary>
        /// 在当前位置前插入数据
        /// </summary>
        public void Insert(int DataValue)
        {
            ListNode NewNode = new ListNode(DataValue);
            if (IsNull())
            {
                //为空表,则添加
                Append(DataValue);
                return;
            }
            if (IsBof())
            {
                //为头部插入
                NewNode.Next = Head;
                Head.Previous = NewNode;
                Head = NewNode;
                Current = Head;
                ListCountValue += 1;
                return;
            }
            //中间插入
            NewNode.Next = Current;
            NewNode.Previous = Current.Previous;
            Current.Previous.Next = NewNode;
            Current.Previous = NewNode;
            Current = NewNode;
            ListCountValue += 1;
        }
        /**//**//**//// <summary>
        /// 进行升序插入
        /// </summary>
        public void InsertAscending(int InsertValue)
        {
            //参数:InsertValue 插入的数据
            //为空链表
            if (IsNull())
            {
                //添加
                Append(InsertValue);
                return;
            }
            //移动到头
            MoveFrist();
            if ((InsertValue < GetCurrentValue()))
            {
                //满足条件,则插入,退出
                Insert(InsertValue);
                return;
            }
            while (true)
            {
                if (InsertValue < GetCurrentValue())
                {
                    //满族条件,则插入,退出
                    Insert(InsertValue);
                    break;
                }
                if (IsEof())
                {
                    //尾部添加
                    Append(InsertValue);
                    break;
                }
                //移动到下一个指针
                MoveNext();
            }
        }
        /**//**//**//// <summary>
        /// 进行降序插入
        /// </summary>
        public void InsertUnAscending(int InsertValue)
        {
            //参数:InsertValue 插入的数据
            //为空链表
            if (IsNull())
            {
                //添加
                Append(InsertValue);
                return;
            }
            //移动到头
            MoveFrist();
            if (InsertValue > GetCurrentValue())
            {
                //满足条件,则插入,退出
                Insert(InsertValue);
                return;
            }
            while (true)
            {
                if (InsertValue > GetCurrentValue())
                {
                    //满族条件,则插入,退出
                    Insert(InsertValue);
                    break;
                }
                if (IsEof())
                {
                    //尾部添加
                    Append(InsertValue);
                    break;
                }
                //移动到下一个指针
                MoveNext();
            }
        }
    }
}
 #endregion

3、栈操作实现
namespace StackNameSpace
{
    /**//// <summary>
    /// Class1 的摘要说明。
    /// </summary>
    public class Stack
    {
        -- 栈类 --#region -- 栈类 --
        private int count = 0;
        private Node first = null;//定义首结点
        public bool Empty
        {
            get
            {
                return (first == null);
            }
        }
        public int Count
        {
            get
            {
                return count;
            }
        }
        public object Pop()//入栈
        {
            if (first == null)
            {
                throw new InvalidOperationException("Can not pop from an empty stack;");
            }
            else
            {
                object temp = first.Value;
                first = first.Next;
                count--;
                return temp;
            }
        }
        public void push(object o)//出栈
        {
            first = new Node(o, first);
            count++;
        }
        public Stack()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }
        #endregion
    }
    class Node
    {
        -- 结点类 --#region -- 结点类 --
        public Node Next;
        public object Value;
        public Node(object value) : this(value, null) { }
        public Node(object value, Node next)
        {
            Next = next;
            Value = value;
        }
        #endregion
    }
}

三、其他算法
1、
-- 堆排序(小根堆) --#region -- 堆排序(小根堆) --
        public static void heapSort(int[] input)
        {
            int root_count = input.Length / 2;
            for (int i = root_count - 1; i >= 0; i--)
            {
                int left = 0;
                int right = 0;
                if (2 * i + 1 < input.Length) left = input[2 * i + 1];
                if ((2 * i + 2) < input.Length) right = input[2 * i + 2];
                if (left >= right && left > input[i])
                {
                    Sort.swap(ref input[i], ref input[2 * i + 1]);
                    Sort.nodeSort(input, 2 * i + 1, input.Length - 1);
                }
                else if (right >= left && right > input[i])
                {
                    Sort.swap(ref input[i], ref input[2 * i + 2]);
                    Sort.nodeSort(input, 2 * i + 2, input.Length - 1);
                }
            }
            for (int j = input.Length - 1; j > 0; j--)
            {
                Sort.swap(ref input[0], ref input[j]);
                Sort.nodeSort(input, 0, j - 1);
            }
        } 

        public static void nodeSort(int[] input, int index,int end)
        {
            //左孩子存在
            while ((2 * index + 1) <= end)
            {
                //右孩子存在
                if ((2 * index + 2) <= end)
                {
                    //左孩子大
                    if (input[2 * index + 1] >= input[2 * index + 2] && input[2 * index + 1] > input[index])
                    {
                        Sort.swap(ref input[index], ref input[index * 2 + 1]);
                        index = 2 * index + 1;
                    }
                    //右孩子大
                    else if (input[2 * index + 2] >= input[2 * index + 1] && input[2 * index + 2] > input[index])
                    {
                        Sort.swap(ref input[index], ref input[index * 2 + 2]);
                        index = 2 * index + 2;
                    }
                    //父节点大
                    else
                    {
                        return;
                    }
                }
                else
                //右孩子不存在
                {
                    //左孩子大
                    if (input[2 * index + 1] > input[index])
                    {
                        Sort.swap(ref input[index], ref input[index * 2 + 1]);
                        index = 2 * index + 1;
                    }
                    else
                    {
                        //父节点大
                        return;
                    }
                }
            }
        }
        #endregion

相关文章推荐

数据结构算法与应用

  • 2015年07月21日 12:05
  • 11.25MB
  • 下载

PHP数据结构之六 PHP栈的应用举例【数制转换和括号匹配算法】

PHP栈的应用举例【数制转换和括号匹配算法】 /** *栈的应用举例 * *1.十进制整数转换为二、八、十六进制整数 *2.括号匹配问题 */ header("content-typ...
  • nuli888
  • nuli888
  • 2016年08月08日 15:50
  • 215

数据结构算法与应用–C++语言描述

  • 2014年08月21日 12:18
  • 16.48MB
  • 下载

数据结构算法与应用C++语言描述

  • 2013年07月12日 13:30
  • 15.14MB
  • 下载

数据结构与算法——栈的作用及应用

作用: 栈的引入简化了程序设计的问题,划分了不同的关注层次,使得思考范围缩小,更加聚焦于要解决的问题核心。反之,像数组等,因为要分散精力去考虑数组的下标增减等细节问题,反而掩盖了问题的本质。 应用...

数据结构算法与应用-C__语言

  • 2013年09月24日 14:48
  • 11.23MB
  • 下载

树结构应用之MySQL索引背后的数据结构及算法原理

MySQL索引背后的数据结构及算法原理
  • zolalad
  • zolalad
  • 2014年07月28日 09:30
  • 740

数据结构算法与应用-C++语言描述

  • 2012年05月17日 21:22
  • 16.77MB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:算法、结构应用
举报原因:
原因补充:

(最多只允许输入30个字)