关闭

算法、结构应用

标签: 算法inputlistnullinsertobject
714人阅读 评论(0) 收藏 举报
分类:

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

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
0
0
查看评论

Web结构挖掘算法概述及应用

    WEB结构挖掘算法概述及应用Web结构挖掘算法概述及应用[内容提要] Web 结构挖掘是对Web 的链接结构进行分析。本文概述Web结构挖掘技术,列举其常见算法。并对PageRank和HITS这两种最重要的Web结构挖掘算法分析比较。通过对算法规律的研究,指出在...
  • zhanghefu
  • zhanghefu
  • 2007-03-25 13:42
  • 4195

结构类型的定义,应用

1.结构类型定义 结构类型将不同的数据类型组合起来,结构类型定义并没有说明任何实际的变量,它仅仅是定义一种特殊的数据类型; 结构类型定义本身为一条语句,以分号终止; 定义的一般形式:          ...
  • u011125106
  • u011125106
  • 2016-12-10 19:55
  • 171

android 应用程序结构是哪些

android 应用程序结构
  • xiaopihair123
  • xiaopihair123
  • 2016-11-13 15:14
  • 1778

【Bitmap算法浅谈篇】Mysql应用Bitmap

首先Bitmap算法并不是一种数学公式,而是一种方法! 下面通过一个列子来使你明白何为Bitmap算法!以下数据库以mysql为列! 给出一个表结构,每一行都表示一条记录! 1、要想统计所有70后的演员怎么做? Select cou...
  • qq_22520215
  • qq_22520215
  • 2017-09-08 18:05
  • 555

OpenCV基于点阵结构光的主动立体双目深度图三维重建算法

System Status: 2 IR cameras(OV9281) + 1 laser projector(HEPTAGON LIMA2.0-SD-0) Using Active Stereo method, not coded structure light( coding and decod...
  • u013626386
  • u013626386
  • 2017-03-21 16:13
  • 2209

三层应用结构

所谓三层结构是针对于过去的主机终端模式或者服务器客户机模式的区别而成的,它的特点是在后台有一个后端数据支持服务器,在中端有一群应用服务器,提供结合用户业务和具体应用的相关系统解决方案,在前端会有很多的接入设备,通过接入设备与客户机连接,如图1所示。      ...
  • an9el
  • an9el
  • 2005-07-28 01:06
  • 1152

《结构方程模型及其应用》学习笔记0504第一、二章

《结构方程模型及其应用》学习笔记0504第一、二章
  • xiaopchao
  • xiaopchao
  • 2015-05-04 16:31
  • 1096

C#数据结构和算法学习系列六----堆栈、堆栈的实现和应用

堆栈和队列是两种面向表的数据结构,它们都提供了易于理解的抽象。堆栈中的数据只能在表的某一端进行添加和删除操作,反之队列中的数据则在表的一端进行添加操作而在表的另一端进行删除操作。堆栈被广泛用于从表达式计算到处理函数调用的任何编程语言的实现中。而队列则用在区分优先次序的操作系统处理
  • nlx0201
  • nlx0201
  • 2011-09-12 10:58
  • 2741

密码学算法及应用(二)

密码学六元组 - 明文- 密文- 加密算法- 解密算法- 加密秘钥- 解密秘钥     其中加密算法和解密算法一般都是公开的,只有公开的算法才能被验证是安全的。不要试图开发自己的保密加密算法,一旦算法泄露,加密体系就崩溃了。所以加密时要选用公开的算法。...
  • u013031185
  • u013031185
  • 2016-11-13 21:57
  • 800

基于 ReliefF和K-means算法的应用

数据挖掘方法的提出,让人们有能力最终认识数据的真正价值,即蕴藏在数据中的信息和知识。数据挖掘 (DataMiriing),指的是从大型数据库或数据仓库中提取人们感兴趣的知识,这些知识是隐含的、事先未知的潜在有用信息,数据挖掘是目前国际上,数据库和信息决策领域的最前沿研究方向之一。因此分享一下很久以前...
  • pangjiuzala
  • pangjiuzala
  • 2015-11-28 23:32
  • 2809
    个人资料
    • 访问:406674次
    • 积分:5495
    • 等级:
    • 排名:第5779名
    • 原创:143篇
    • 转载:70篇
    • 译文:0篇
    • 评论:58条
    最新评论